Introduction
यह अध्याय subgroups (उपसमूहों) और generators (जनकों) के बारे में विस्तार से बताकर ग्रुप थ्योरी (group theory) के हमारे अध्ययन को आगे बढ़ाता है। अंत में एक primitive element की अवधारणा को प्रस्तुत किया जाएगा। हम यह मानकर चलते हैं कि आप पहले से ही एक ग्रुप (group) की परिभाषा से परिचित हैं। यदि आपको इसे फिर से समझने की आवश्यकता है, तो this article देखें।
समझ विकसित करने के लिए, हम additive groups से शुरुआत करते हैं, जो सीधे और सरल होते हैं तथा subgroups और generators जैसी मुख्य अवधारणाओं को स्पष्ट करने में मदद करते हैं।
इसके बाद हम multiplicative groups of integers modulo की ओर बढ़ते हैं। गुणा (multiplication) के अंतर्गत, पूर्णांक (integers) स्वयं एक ग्रुप नहीं बनाते हैं— में केवल और के मल्टीप्लिकेटिव इन्वर्स (multiplicative inverses) होते हैं, इसलिए ग्रुप के नियम विफल हो जाते हैं। इसे हल करने के लिए, हम से छोटे उन पूर्णांकों पर ध्यान केंद्रित करते हुए मॉड्यूलो (modulo ) गुणा पर विचार करते हैं जो इसके coprime (सह-अभाज्य) हैं। इन coprime पूर्णांकों के मॉड्यूलो मल्टीप्लिकेटिव इन्वर्स होते हैं, और ये मिलकर एक अच्छी तरह से परिभाषित ग्रुप बनाते हैं। यह संरचना नंबर थ्योरी (number theory) में केंद्रीय भूमिका निभाती है और कई क्रिप्टोग्राफ़िक सिस्टम (cryptographic systems) का आधार है।
Coprime: दो संख्याएँ coprime होती हैं यदि उनका महत्तम समापवर्तक (Greatest Common Divisor - GCD) 1 हो।
Example 1: 8 और 15 coprime हैं क्योंकि
8 के गुणनखंड (Factors): 1, 2, 4, 8
15 के गुणनखंड: 1, 3, 5, 15
सामान्य गुणनखंड (Common factor): 1
gcd 1 है।Example 2: 12 और 18 coprime नहीं हैं क्योंकि
12 के गुणनखंड: 1, 2, 3, 4, 6, 12
18 के गुणनखंड: 1, 2, 3, 6, 9, 18
सामान्य गुणनखंड: 1, 2, 3, 6
gcd 6 है।
अंत में, हम generators का परीक्षण करते हैं—ऐसे एलिमेंट्स जो बार-बार गुणा करने के माध्यम से एक संपूर्ण ग्रुप या subgroup का निर्माण कर सकते हैं। generators को समझने से महत्वपूर्ण subgroup संरचनाओं का पता चलता है, विशेष रूप से जब अभाज्य (prime) हो, और यह क्रिप्टोग्राफ़िक अनुप्रयोगों (cryptographic applications) में उनकी महत्वपूर्ण भूमिका को उजागर करता है।
1. Additive Groups
एडिटिव ग्रुप्स में ऑपरेशन के रूप में जोड़ (अक्सर किसी संख्या के मॉड्यूलो) का उपयोग किया जाता है, जिसमें आइडेंटिटी एलिमेंट होता है और किसी एलिमेंट का इन्वर्स होता है, जिससे इनकी संरचना अपेक्षाकृत सरल हो जाती है। आइए उदाहरणों के माध्यम से समझें कि वे कैसे काम करते हैं।
1.1 Example:
शुरुआत करने के लिए, जोड़ (addition) के अंतर्गत पर विचार करें। closure के साथ शुरू करें:
हमें सेट से बाहर ले जाता है। इसे ठीक करने के लिए, हम addition modulo 6 का उपयोग करते हैं:
अब प्रत्येक परिणाम में रहता है। यहाँ एडिशन टेबल दी गई है:
प्रत्येक परिणाम में है, इसलिए closure लागू होता है। अन्य गुणों की जाँच करें:
- Associativity: ग्रुपिंग (Grouping) से परिणाम नहीं बदलता है:
- ,
- .
- Identity: आइडेंटिटी एलिमेंट के रूप में काम करता है, क्योंकि (टेबल की पहली पंक्ति या कॉलम देखें)।
- Inverses: प्रत्येक एलिमेंट का एक जोड़ा होता है जिसका योग होता है:
| Element | Inverse | Check |
|---|---|---|
इस प्रकार, एक ग्रुप है जिसका order (सेट में एलिमेंट्स की संख्या) है।
Exercise 1.1: जाँच करें कि क्या एक ग्रुप है।
Hint: की तरह ही एडिशन टेबल बनाने का प्रयास करें।
इसे हाथ से करना थोड़ा थकाऊ हो सकता है, इसलिए यहाँ एक Python स्क्रिप्ट दी गई है जो किसी भी के लिए पूर्ण एडिशन टेबल जनरेट करेगी:
def print_addition_table(mod):
header = ["+ mod " + str(mod)] + list(range(mod))
print(" | ".join(str(h).rjust(4) for h in header))
print("-" * (6 * (mod + 1)))
for row in range(mod):
line = [str(row).rjust(4)]
for col in range(mod):
value = row + col
result = value % mod
if value >= mod:
line.append(f"{value} ≡ {result}".rjust(6))
else:
line.append(str(result).rjust(6))
print(" | ".join(line))
# Try it with Z_9
print_addition_table(9)
Follow-up: का विश्लेषण करने के बाद, के लिए टेबल जनरेट करने का प्रयास करें। क्या आप निर्धारित कर सकते हैं कि भी एक ग्रुप है?
इस प्रकार, , order वाला एक ग्रुप है। इस तरह के फाइनाइट ग्रुप्स (Finite groups) मॉड्यूलर अरिथमेटिक (modular arithmetic) और क्रिप्टोग्राफ़ी में महत्वपूर्ण हैं। इसके बाद, हम अपना ध्यान इस ओर मोड़ते हैं कि किसी ग्रुप के भीतर कुछ विशेष एलिमेंट्स और सबसेट्स (subsets) कैसे गहरी संरचना को प्रकट कर सकते हैं—subgroups और generators के माध्यम से।
2. Subgroups और Generators
2.1 Subgroups को समझना
ग्रुप्स का अध्ययन करते समय, हमारा सामना अक्सर ऐसे सबसेट्स (subsets) से होता है जो समान ऑपरेशन के अंतर्गत ग्रुप की संरचना को बनाए रखते हैं। ये विशेष सबसेट्स, जिन्हें subgroups कहा जाता है, मूल ग्रुप के छोटे संस्करणों की तरह व्यवहार करते हैं। हालाँकि, हर सबसेट इसके योग्य नहीं होता है—आइए उदाहरणों के साथ इसे समझें कि क्या चीज़ एक subgroup बनाती है।
Example 2.1.1: Subgroups in
जोड़ के अंतर्गत सभी पूर्णांकों के ग्रुप , और दो परिचित सबसेट्स पर विचार करें:
- सम पूर्णांकों (even integers) का सेट:
- विषम पूर्णांकों (odd integers) का सेट:
आइए सम पूर्णांकों की जाँच करें:
- Closure: दो सम संख्याओं का योग सम होता है (उदाहरण के लिए, ).
- Identity: सम है और इसमें शामिल है।
- Inverses: किसी भी सम संख्या का इन्वर्स भी सम होता है (उदाहरण के लिए, का इन्वर्स है)।
- Associativity: से प्राप्त होती है (Inherited)।
सम पूर्णांक ग्रुप के सभी गुणों को संतुष्ट करते हैं—यह एक मान्य subgroup है।
अब विषम पूर्णांकों की जाँच करें:
- Closure: , जो कि सम है—सेट का हिस्सा नहीं है। इसलिए closure विफल हो जाता है।
- Identity: विषम नहीं है, इसलिए आइडेंटिटी एलिमेंट गायब है।
- Inverses: के लिए, विषम है—लेकिन चूँकि closure और identity पहले ही विफल हो चुके हैं, इसलिए यह एक subgroup नहीं है।
जोड़ के अंतर्गत विषम पूर्णांक subgroup मानदंडों को पूरा नहीं करते हैं—वे केवल एक सबसेट हैं, subgroup नहीं।
Example 2.1.2: Subgroups in
अब लें और दो सबसेट्स का परीक्षण करें:
- Evens modulo 8:
- First half:
के लिए:
- Closure: , (दोनों सेट में हैं)।
- Identity: मौजूद है।
- Inverses: , , (सभी जोड़े काम करते हैं)।
- Associativity: से लागू होती है।
यह एक subgroup है!
के लिए:
- Closure: (सेट में नहीं है)।
- Identity: मौजूद है।
- Inverses: के लिए, में कोई भी एलिमेंट नहीं देता है (उदाहरण के लिए, )।
यह एक ग्रुप होने में विफल रहता है, इसलिए यह केवल एक सबसेट है, subgroup नहीं।
Definition: किसी ग्रुप का सबसेट एक subgroup होता है यदि वह उसी ऑपरेशन के अंतर्गत एक ग्रुप हो, जिसका अर्थ है कि यह closure को संतुष्ट करता है, इसमें identity शामिल है, इसके सभी एलिमेंट्स के लिए inverses हैं, और यह से associativity प्राप्त करता है।
Exercise 2.1.1: के सभी subgroups खोजें।
2.2 Additive Groups में Generators
अब जब हमने subgroups को देख लिया है, तो आइए जानें कि कैसे सिंगल एलिमेंट्स उन्हें—या यहाँ तक कि पूरे ग्रुप को—जनरेट कर सकते हैं। हम पर फिर से विचार करेंगे, जो मॉड्यूलो एडिशन के अंतर्गत एडिटिव ग्रुप है, और जाँच करेंगे कि क्या होता है जब हम किसी एलिमेंट को बार-बार उसी में जोड़ते हैं, जैसे कि मॉड्यूलो संख्याओं के चारों ओर “घूमना”।
Example 2.2.1: Generators in
Try 1:
यह देता है। बार-बार जोड़ने से संपूर्ण ग्रुप में चक्र (cycle) चलता है।
Try 2:
यह देता है—केवल आधा ग्रुप।
Try 3:
यह देता है, और भी छोटा!
Try 5:
यह देता है, जो की तरह ही सब कुछ कवर करता है।
Exercise 2.2.1: में, कौन से एलिमेंट्स संपूर्ण जनरेट करते हैं? कौन से एलिमेंट्स proper subgroups जनरेट करते हैं?
2.2.2 Subgroups Generated by Elements
अब बाइनरी ऑपरेशन (जैसे जोड़ या गुणा) वाले किसी भी ग्रुप पर विचार करें, और मान लें कि , का एक एलिमेंट है। ग्रुप ऑपरेशन को पर बार-बार लागू करके, हम इसके द्वारा जनरेट किए गए एलिमेंट्स का सेट बना सकते हैं। इस सेट को से दर्शाया जाता है और इसे द्वारा जनरेट किया गया cyclic subgroup कहा जाता है।
उदाहरण के लिए additive groups में:
कई एलिमेंट्स के लिए, एक proper subgroup होता है। लेकिन जब होता है, तो हम कहते हैं कि , का एक generator है, और एक cyclic group है।
जैसा कि Example 2.2.1 में दिखाया गया है, हमने मॉड्यूलो 6 एडिशन के अंतर्गत में एलिमेंट्स द्वारा जनरेट किए गए subgroups की गणना की। प्रत्येक एलिमेंट द्वारा जनरेट किए गए subgroups इस प्रकार हैं:
- (proper subgroup)
- (proper subgroup)
- (proper subgroup)
- (proper subgroup)
एलिमेंट्स और संपूर्ण ग्रुप जनरेट करते हैं, जिससे वे generators बन जाते हैं, जबकि , , , और proper subgroups जनरेट करते हैं।
Example 2.2.3: Generators in
अब मॉड्यूलो 5 एडिशन के अंतर्गत का परीक्षण करें:
प्रत्येक गैर-शून्य (non-zero) एलिमेंट एक generator है।
ऐसा इसलिए होता है क्योंकि सभी के लिए है, और अभाज्य (prime) है।
Conclusion: में, एक एलिमेंट संपूर्ण ग्रुप को तभी जनरेट करता है जब हो। अभाज्य के लिए, सभी गैर-शून्य एलिमेंट्स generators होते हैं। भाज्य (composite) के लिए, केवल कुछ ही एलिमेंट्स योग्य होते हैं।
2.3 Code: में Additive Generators की खोज
def additive_closure(a, n):
"""Generates {0, a, 2a, 3a, ...} mod n until it repeats."""
result = []
current = 0
while current not in result:
result.append(current)
current = (current + a) % n
return sorted(result) # Sorted for readability
# Show generated sets in (Z_6 , +)
print("Z_6:")
for a in range(6):
print(f"Generated by {a}: {additive_closure(a, 6)}")
# Show generated sets in (Z_5, +)
print("\nZ_5:")
for a in range(5):
print(f"Generated by {a}: {additive_closure(a, 5)}")
Output:
(Z_6, +):
Generated by 0: [0]
Generated by 1: [0, 1, 2, 3, 4, 5]
Generated by 2: [0, 2, 4]
Generated by 3: [0, 3]
Generated by 4: [0, 2, 4]
Generated by 5: [0, 1, 2, 3, 4, 5]
(Z_5, +):
Generated by 0: [0]
Generated by 1: [0, 1, 2, 3, 4]
Generated by 2: [0, 1, 2, 3, 4]
Generated by 3: [0, 1, 2, 3, 4]
Generated by 4: [0, 1, 2, 3, 4]
एडिटिव ग्रुप्स (additive groups) की खोज करने के बाद, अब हम उनके मल्टीप्लिकेटिव समकक्षों (multiplicative counterparts) की ओर मुड़ते हैं।
3. Multiplicative Groups
मल्टीप्लिकेटिव ग्रुप्स गुणा (अक्सर किसी संख्या के मॉड्यूलो) के अंतर्गत काम करते हैं, जिसमें आइडेंटिटी एलिमेंट होता है, हालांकि इन्वर्सेस ढूँढना थोड़ा जटिल हो सकता है, विशेष रूप से फाइनाइट सेटिंग्स में। इसे स्पष्ट करने के लिए, हम मॉड्यूलो गुणा का उपयोग करके एक ठोस उदाहरण की जाँच करेंगे।
3.1 Example:
पर विचार करें:
- Closure लागू होता है, उदा., , सेट में है।
- Identity: आइडेंटिटी एलिमेंट है, लेकिन यह के लिए विफल रहता है, जिसका कोई इन्वर्स नहीं है;
- Inverses: प्रत्येक गैर-शून्य एलिमेंट का एक इन्वर्स होता है:
चूँकि का कोई इन्वर्स नहीं है, इसलिए एक ग्रुप नहीं है। लेकिन यदि हम को हटा दें और केवल गैर-शून्य एलिमेंट्स पर विचार करें — अर्थात, — तो हमें गुणा के अंतर्गत एक ग्रुप मिल जाता है। इस सेट को अक्सर से दर्शाया जाता है और यह 6 आर्डर का एक ग्रुप है।
आप किसी भी मॉड्यूलो के लिए गुणन तालिका (multiplication table) जनरेट करने के लिए इस कोड का उपयोग कर सकते हैं:
def print_multiplication_table(mod):
header = ["× mod " + str(mod)] + list(range(mod))
print(" | ".join(str(h).rjust(4) for h in header))
print("-" * (6 * (mod + 1)))
for row in range(mod):
line = [str(row).rjust(4)]
for col in range(mod):
value = row * col
result = value % mod
if value >= mod:
line.append(f"{value} ≡ {result}".rjust(6))
else:
line.append(str(result).rjust(6))
print(" | ".join(line))
print_multiplication_table(5)
3.2 Example: , एक ग्रुप नहीं है
आइए अब गुणा mod 6 के अंतर्गत सेट का परीक्षण करें।
| 1 | |||||
| 2 | |||||
| 3 | |||||
| 4 | |||||
| 5 |
अब हमारे पास एक अधिक बुनियादी समस्या है: कुछ गुणाओं का परिणाम 0 होता है जो सेट का हिस्सा नहीं है। इसलिए, यह सेट और बाइनरी ऑपरेटर क्लोज्ड (closed) नहीं है, इसलिए यह एक ग्रुप नहीं है।
3.3 Example:
एक अन्य उदाहरण के रूप में, आइए अब में गुणा पर विचार करें:
केवल वे एलिमेंट्स —जो 8 के साथ coprime हैं—में मॉड्यूलो 8 मल्टीप्लिकेटिव इन्वर्स होते हैं:
शेष एलिमेंट्स, , सभी 8 के साथ एक सामान्य गुणनखंड (common factor) साझा करते हैं और इसलिए उनके इन्वर्स नहीं होते हैं। इस प्रकार, गुणा के अंतर्गत एक ग्रुप नहीं है।
3.4. क्या है?
सेट को औपचारिक रूप से इस प्रकार परिभाषित किया गया है:
अर्थात, में के वे सभी एलिमेंट्स शामिल हैं जिनका एक मल्टीप्लिकेटिव इन्वर्स मॉड्यूलो होता है।
-
जब अभाज्य (prime) हो, तो प्रत्येक गैर-शून्य एलिमेंट इन्वर्टिबल (invertible) होता है, इसलिए:
-
जब भाज्य (composite) हो, तो केवल के coprime एलिमेंट्स ही इन्वर्टिबल होते हैं। उदाहरण के लिए:
दोनों मामलों में, गुणा के अंतर्गत एक ग्रुप बनाता है। हालाँकि, पूर्ण सेट हमेशा एक ग्रुप नहीं बनाता है—जब तक कि अभाज्य न हो।
इससे पहले, हमने यह दर्शाने के लिए का उपयोग किया था कि जब भाज्य होता है तो इन्वर्सेस की अनुपस्थिति (और zero divisors की उपस्थिति) ग्रुप संरचना को क्यों तोड़ देती है। यह अंतर केवल तकनीकी होने से कहीं अधिक है: यह मॉड्यूलर अरिथमेटिक, क्रिप्टोग्राफ़िक एल्गोरिदम और नंबर थ्योरी को समझने में केंद्रीय भूमिका निभाता है।
अगले भाग में, हम यह जानेंगे कि के अभाज्य होने पर की संरचना कैसे बदलती है।
3.5 Prime Moduli क्यों काम करते हैं
ये विफलताएँ prime moduli को प्रेरित करती हैं। में, जहाँ अभाज्य है, प्रत्येक एलिमेंट का एक इन्वर्स होता है। वास्तव में, यह नंबर थ्योरी के एक क्लासिक परिणाम द्वारा गारंटीकृत है।
मॉड्यूलो के लिए के पैटर्न पर विचार करें:
- यदि अभाज्य नहीं है, तो यह zero divisors और गायब इन्वर्सेस के कारण एक ग्रुप नहीं है (उदाहरण के लिए, )।
- यदि अभाज्य है, तो यह एक ग्रुप है।
3.6 Inverse की गणना के लिए Python कोड
मॉड्यूलर इन्वर्सेस की गणना करने के लिए सबसे सरल और सबसे कुशल तरीकों में से एक Python के अंतर्निहित
pow(a, -1, p) का उपयोग करना है। पर्दे के पीछे, यह नंबर थ्योरी के एक प्रसिद्ध परिणाम के कारण काम करता है जिसे Fermat’s Little Theorem कहा जाता है, जो गारंटी देता है कि एक इन्वर्स मौजूद है और हमें बताता है:
जब मॉड्यूलो एक अभाज्य संख्या है और , से विभाज्य नहीं है।
यहाँ एक उदाहरण है:
def mod_inverse(a, p):
return pow(a, -1, p)
# Test for Z_7^*
def test_inverses(p):
print(f"Testing inverses modulo {p}:")
for a in range(1, p):
inv = mod_inverse(a, p)
print(f"Inverse of {a} mod {p} is {inv} (check: {a} * {inv} = {a * inv % p})")
if __name__ == "__main__":
p = 7
test_inverses(p)
Output:
Testing inverses modulo 7:
Inverse of 1 mod 7 is 1 (check: 1 * 1 = 1)
Inverse of 2 mod 7 is 4 (check: 2 * 4 = 1)
Inverse of 3 mod 7 is 5 (check: 3 * 5 = 1)
Inverse of 4 mod 7 is 2 (check: 4 * 2 = 1)
Inverse of 5 mod 7 is 3 (check: 5 * 3 = 1)
Inverse of 6 mod 7 is 6 (check: 6 * 6 = 1)
3.7 Exercises
Math Exercises:
-
Python के
pow(a, -1, n)फ़ंक्शन या कैलकुलेटर का उपयोग करके निम्नलिखित के लिए मॉड्यूलर इन्वर्स (यदि यह मौजूद है) खोजें। Prime moduli के लिए, आप वैकल्पिक रूप से Fermat’s Little Theorem का उपयोग कर सकते हैं: -
में के किन मानों के लिए मॉड्यूलर इन्वर्स मौजूद है?
Coding Exercises:
-
एक फ़ंक्शन
list_all_inverses(n)लिखें जो के सभी एलिमेंट्स का उनके इन्वर्सेस (यदि वे मौजूद हैं) के साथ एक डिक्शनरी (dictionary) लौटाता है। -
एक प्रोग्राम लिखें जो यूजर इनपुट
aऔरnलेता है, और जाँच करता है कि क्या कोई मॉड्यूलर इन्वर्स मौजूद है। यदि यह मौजूद है, तो इन्वर्स प्रिंट करें। इसे अलग-अलग मानों के साथ आज़माएँ और देखें कि आप क्या खोजते हैं। -
Challenge: कुछ छोटे primes
pचुनें, और एक प्रोग्राम लिखें जो यह जाँचता हो कि क्या
{1, 2, ..., p - 1}में सभीaके लिएpow(a, p - 1, p) == 1है।
क्या यह प्रत्येकaके लिए सही है? यदिpअभाज्य (prime) नहीं है तो क्या होता है?
4. Multiplicative Groups में Generators
अब हम अपना ध्यान multiplicative groups में generators की ओर मोड़ते हैं। समझ विकसित करने के लिए, हम में ठोस उदाहरणों से शुरू करते हैं, यह पता लगाते हुए कि कैसे अलग-अलग एलिमेंट्स बार-बार गुणा करके पूर्ण ग्रुप—या इसके सिर्फ एक हिस्से—को जनरेट कर सकते हैं।
Example 4.1:
Try 3:
। एलिमेंट एक generator है।
Try 2:
, एक subgroup, पूर्ण ग्रुप नहीं।
Try Other Elements:
- :
- :
- :
Summary:
| एलिमेंट | जनरेटेड सेट | आकार | जनरेटर? |
|---|---|---|---|
| ❌ | |||
| ✅ | |||
| ❌ | |||
| ✅ | |||
| ❌ |
4.1 Primitive Elements
जैसा कि हम देखते हैं, एडिटिव ग्रुप में, जहाँ अभाज्य है, प्रत्येक गैर-शून्य एलिमेंट के एक generator होने की गारंटी है। यानी, किसी भी गैर-शून्य एलिमेंट को बार-बार जोड़ने पर अंततः ग्रुप के सभी एलिमेंट्स का चक्र (cycle) पूरा हो जाएगा। हालाँकि, मल्टीप्लिकेटिव ग्रुप्स में, केवल कुछ ही एलिमेंट्स generators होते हैं—इन्हें primitive elements कहा जाता है। यह विषमता एक मूलभूत अंतर को उजागर करती है: primes पर एडिटिव ग्रुप्स हमेशा cyclic होते हैं जिनमें सभी गैर-शून्य एलिमेंट्स generators होते हैं, जबकि primes पर मल्टीप्लिकेटिव ग्रुप्स cyclic तो होते हैं लेकिन उनमें एलिमेंट्स का केवल एक सबसेट (subset) ही होता है जो generators के रूप में काम करता है।
Definition: एक एलिमेंट एक primitive element है यदि
उदाहरण के लिए, लें: और primitive elements हैं, जबकि , , और नहीं हैं।
नंबर थ्योरी में एक foundational result इस बात की गारंटी देता है कि किसी भी अभाज्य के लिए, ग्रुप cyclic होता है, जिसका अर्थ है कि इसमें हमेशा कम से कम एक primitive element शामिल होता है। यह एडिटिव ग्रुप के विपरीत है, जहाँ प्रत्येक गैर-शून्य एलिमेंट संपूर्ण ग्रुप जनरेट करता है।
Example 4.1.1:
-
Element 2:
, इसलिए एक primitive element है। -
Element 3:
, इसलिए भी एक primitive element है।
Example 4.1.2:
-
Element 2:
, इसलिए एक primitive element है। -
Element 3:
, एक subgroup, पूर्ण ग्रुप नहीं।
Example 4.1.3:
-
Element 3:
, आर्डर (पूर्ण ग्रुप)। अतः, , का एक primitive element है।
Additional Note: हालाँकि हमने पहले बताया था कि हमेशा एक ग्रुप होता है, लेकिन जब अभाज्य नहीं होता है तो यह हमेशा cyclic नहीं होता है। इसके विपरीत, जब अभाज्य होता है, तो हमेशा cyclic होता है। यह अंतर व्यवहार में मायने रखता है—विशेष रूप से क्रिप्टोग्राफ़ी में—जहाँ हम cyclic groups के साथ काम करना पसंद करते हैं, इसलिए हम अक्सर prime moduli को चुनते हैं ताकि यह सुनिश्चित हो सके कि में यह cyclic संरचना है।
4.2 Python Code: एक Prime के Modulo Primitive Elements खोजना
में primitive elements खोजने के लिए, हम एक उम्मीदवार (candidate) एलिमेंट द्वारा जनरेट किए गए subgroup की गणना करते हैं और जाँचते हैं कि क्या इसमें के सभी एलिमेंट्स शामिल हैं। निम्नलिखित कोड इस जाँच को निष्पादित करके सत्यापित करता है कि क्या कोई दिया गया एलिमेंट primitive है। आप इसका उपयोग primitive elements के और उदाहरणों का पता लगाने और परीक्षण करने के लिए कर सकते हैं:
def is_primitive_element(g, p):
"""Check if g is a primitive element modulo p."""
required = set(range(1, p))
generated = set()
val = 1
for _ in range(1, p):
val = (val * g) % p
generated.add(val)
return generated == required
def primitive_elements(p):
"""Find all primitive elements of prime p."""
elements = []
for g in range(2, p):
if is_primitive_element(g, p):
elements.append(g)
return elements
# Example usage:
prime = 11
print(f"Primitive elements modulo {prime}: {primitive_elements(prime)}")
Sample Output:
Primitive elements modulo 11: [2, 6, 7, 8]
अधिक कुशल दृष्टिकोण के लिए, galois लाइब्रेरी सीधे finite field के multiplicative group में primitive elements की गणना कर सकती है, जो एक अभाज्य के लिए से मेल खाती है। सबसे पहले, pip install galois के साथ लाइब्रेरी इंस्टॉल करें, फिर उपयोग करें:
import galois
print(galois.GF(7).primitive_elements) # Output: [3, 5]
यह विधि बड़े primes के लिए अनुकूलित (optimized) है, जो इसे व्यावहारिक अनुप्रयोगों (practical applications) के लिए आदर्श बनाती है, जबकि ऊपर दिया गया मैन्युअल कोड primitive elements की अवधारणा को समझने में मदद करता है।
Exercise
आइए हमने generators और primitive elements के बारे में जो सीखा है उसे लागू करें।
-
का एक generator खोजने के लिए ऊपर दिए गए Python कोड का उपयोग करें।
(Hint: आप एक ऐसे एलिमेंट की तलाश कर रहे हैं जिसकी घातें (powers) के सभी एलिमेंट्स जनरेट करती हों।) -
के रूप में के सभी एलिमेंट्स को सूचीबद्ध करने के लिए अपने generator का उपयोग करें।
(Hint: आपको 12 अलग-अलग घातें (powers) मिलनी चाहिए।) -
के निम्नलिखित प्रत्येक मान के लिए, द्वारा जनरेट किए गए subgroup को लिखें।
(Hint: यह दृष्टिकोण आपको ब्रूट फोर्स (brute force) के बिना सभी subgroups को खोजने में मदद करता है। उदाहरण के लिए, नीचे के मामले पर विचार करें)
Example:
यदि ( का एक generator), तो:
- द्वारा जनरेट किया गया subgroup है:
अब इसे के लिए आज़माएँ।
(Remember: पहले की गणना करें, फिर मॉड्यूलो 13 में इसकी क्रमिक घातों (successive powers) को तब तक सूचीबद्ध करें जब तक कि आप वापस 1 पर न आ जाएँ।)
- के सभी distinct subgroups को सूचीबद्ध करने के लिए अपने ऊपर दिए गए कार्य का उपयोग करें।
(Hint: की कुछ घातें एक ही subgroup जनरेट करती हैं।)
Conclusion:
इस अध्याय में एक अभाज्य (prime) के मॉड्यूलो मल्टीप्लिकेटिव ग्रुप्स और उनकी subgroup संरचनाओं को समझने पर ध्यान केंद्रित किया गया। हमने देखा कि ये ग्रुप्स cyclic होते हैं, जिसका अर्थ है कि वे एक सिंगल एलिमेंट द्वारा जनरेट किए जा सकते हैं — जिसे primitive element कहा जाता है। हमने यह भी पता लगाया कि कैसे एक primitive element की घातें (powers) cyclic subgroups जनरेट करती हैं, और कैसे अलग-अलग घातें अलग-अलग subgroups का निर्माण करती हैं।
चूँकि हमने अभी तक Lagrange’s Theorem जैसे औपचारिक टूल पेश नहीं किए हैं, इसलिए हमने मैन्युअल रूप से subgroup की खोज की — विशेष रूप से अंतिम अभ्यास में, जहाँ हमने के कुछ मानों को यह देखने के लिए आज़माया कि वे कौन से subgroups जनरेट करते हैं। अगले अध्याय में, आप उन अंतर्निहित सिद्धांतों (underlying principles) को सीखेंगे जो आपको व्यवस्थित रूप से subgroup के आकार और generators निर्धारित करने की अनुमति देते हैं।