View source for बर्स्ट त्रुटि-सुधार करने वाले कोड

{{Short description|Codes intended to correct short, contiguous errors in a communications channel}}
[[कोडिंग सिद्धांत]] में, '''बर्स्ट त्रुटि-सुधार करने वाले कोड''' बर्स्ट त्रुटियों को ठीक करने के विधियों को नियोजित करते हैं, जो त्रुटियां हैं जो एक-दूसरे से स्वतंत्र रूप से बिट्स में होने के अतिरिक्त निरंतर अनेक बिट्स में होती हैं।                                                       

यादृच्छिक त्रुटियों को ठीक करने के लिए अनेक कोड डिज़ाइन किए गए हैं। चूँकि, कभी-कभी चैनल त्रुटियाँ प्रस्तुत कर सकते हैं जो अल्प अंतराल में स्थानीयकृत होती हैं। ऐसी त्रुटियाँ बर्स्ट में होती हैं (जिन्हें बर्स्ट त्रुटियाँ कहा जाता है) क्योंकि वह निरंतर अनेक बिट्स में होती हैं। बर्स्ट त्रुटियों के उदाहरण संग्रहण माध्यमों में बड़े मापदंड पर पाए जा सकते हैं। ये त्रुटियाँ शारीरिक क्षति जैसे डिस्क पर खरोंच या वायरलेस चैनलों के उपस्थिति में विद्युत के झटके के कारण हो सकती हैं। वह स्वतंत्र नहीं हैं; वह स्थानिक रूप से केंद्रित होते हैं। यदि बिट में कोई त्रुटि है, तो संभावना है कि आसन्न बिट्स भी दूषित हो सकते हैं। यादृच्छिक त्रुटियों को ठीक करने के लिए उपयोग की जाने वाली विधियाँ बर्स्ट त्रुटियों को ठीक करने में अक्षम हैं।             

==परिभाषाएँ                                      ==
[[File:Burst Error,Length 5,Description.jpg|thumb|400px|लम्बाई का बर्स्ट 5]]इस प्रकार की लम्बाई का बर्स्ट {{math|ℓ}}<ref name = "Coding Bounds">Coding Bounds for Multiple Phased-Burst Correction and Single Burst Correction Codes</ref> कोडवर्ड बोलो <math>C</math> प्रसारित किया जाता है, और इसे <math>Y = C + E.</math> प्राप्त किया जाता है फिर, त्रुटि सदिश <math>E</math> लम्बाई का बर्स्ट <math>\ell</math> कहलाता है यदि <math>E</math> के गैर-शून्य अवयव <math>\ell</math> तक निरंतर अवयव ही सीमित हैं . उदाहरण के लिए, <math>E = (0\textbf{1000011}0)</math> लम्बाई का बर्स्ट <math>\ell = 7.</math> है 

चूँकि यह परिभाषा यह बताने के लिए पर्याप्त है कि बर्स्ट त्रुटि क्या है, बर्स्ट त्रुटि सुधार के लिए विकसित अधिकांश उपकरण चक्रीय कोड पर निर्भर करते हैं। यह हमारी अगली परिभाषा को प्रेरित करता है।

त्रुटि सदिश <math>E</math> को <math>\ell</math> लंबाई की चक्रीय बर्स्ट त्रुटि कहलाती है यदि इसके गैरशून्य अवयव <math>\ell</math> चक्रीय रूप से निरंतर अवयव तक ही सीमित हैं। उदाहरण के लिए, पहले माना गया त्रुटि सदिश <math>E = (010000110)</math>, लंबाई का चक्रीय बर्स्ट है <math>\ell = 5</math>, चूंकि हम स्थिति से प्रारंभ होने वाली त्रुटि पर विचार करते हैं <math>6</math> और स्थिति <math>1</math> पर समाप्त हो रहा है. ध्यान दें कि सूचकांक हैं <math>0</math>-आधारित, अर्थात पहला अवयव <math>0</math> पर स्थिति है .

इस लेख के शेष भाग के लिए, हम चक्रीय बर्स्ट को संदर्भित करने के लिए बर्स्ट शब्द का उपयोग करेंगे, जब तक कि अन्यथा उल्लेख न किया गया हो।

=== बर्स्ट विवरण                      ===
बर्स्ट त्रुटि की संक्षिप्त परिभाषा रखना अधिकांशतः उपयोगी होता है, जिसमें न केवल इसकी लंबाई, किंतु ऐसी त्रुटि का पैटर्न और स्थान भी सम्मिलित होता है। हम बर्स्ट विवरण को <math>(P,L)</math> टुपल के रूप में परिभाषित करते हैं जहाँ <math>P</math> त्रुटि का पैटर्न है (जो कि त्रुटि पैटर्न में पहली गैर-शून्य प्रविष्टि से प्रारंभ होने वाले और अंतिम गैर-शून्य प्रतीक के साथ समाप्त होने वाले प्रतीकों की स्ट्रिंग है), और <math>L</math> कोडवर्ड पर वह स्थान है, जहां बर्स्ट पाया जा सकता है।<ref name = "Coding Bounds" />

उदाहरण के लिए, त्रुटि पैटर्न <math>E = (010000110)</math> का बर्स्ट विवरण <math>D = (1000011,1)</math> है ध्यान दें कि ऐसा वर्णन अद्वितीय नहीं है, क्योंकि<math>D' = (11001,6)</math> उसी बर्स्ट त्रुटि का वर्णन करता है। सामान्यतः , यदि <math>E</math> में गैर-शून्य अवयव की संख्या <math>w</math> है , तब <math>E</math> में <math>w</math> भिन्न -भिन्न बर्स्ट विवरण होगा, जिनमें से प्रत्येक <math>E</math> भिन्न गैर-शून्य प्रविष्टि पर प्रारंभ होता है . नीचे दिए गए प्रमेय के साथ बर्स्ट विवरण की अस्पष्टता से उत्पन्न होने वाले विवादों को हल करने के लिए, चूंकि ऐसा करने से पहले हमें पहले परिभाषा की आवश्यकता है।

परिभाषा। किसी दिए गए त्रुटि <math>y,</math> पैटर्न में प्रतीकों की संख्या <math>\mathrm{length}(y).</math>द्वारा निरूपित किया जाता है 

{{math theorem | name = Theorem (Uniqueness of burst descriptions) | math_statement = मान लीजिए <math>E</math> लंबाई का त्रुटि सदिश  है <math>n</math> दो बर्स्ट विवरण के साथ <math>(P_1,L_1)</math> and <math>(P_2,L_2)</math>. If <math>\mathrm{length}(P_1) + \mathrm{length}(P_2) \leqslant n + 1,</math> तो दोनों विवरण समान हैं अर्थात् उनके अवयव समतुल्य हैं.<ref>''सूचना और कोडिंग का सिद्धांत: छात्र संस्करण'',आर जे मैकलीस द्वारा</ref> 

<nowiki>{{math proof | proof = </nowiki><math>w</math> [[हैमिंग वज़न]] (या गैर-शून्य प्रविष्टियों की संख्या) हो <math>E</math>. तब <math>E</math> बिलकुल है <math>w</math>त्रुटि विवरण. के लिए <math>w = 0, 1,</math>साबित करने के लिए कुछ भी नहीं है. तो हम ऐसा मान लेते हैं <math>w \geqslant 2</math> और यह कि विवरण समान नहीं हैं। हम देखते हैं कि प्रत्येक गैर-शून्य प्रविष्टि<math>E</math> wमैं पैटर्न में दिखाई दूंगा, और इसी तरह, इसके अवयव  भी<math>E</math> पैटर्न में सम्मिलित नहीं किए जाने पर शून्यों का चक्रीय क्रम बनेगा, जो अंतिम गैर-शून्य प्रविष्टि के पश्चात  प्रारंभ  होगा, और पैटर्न की पहली गैर-शून्य प्रविष्टि से ठीक पहले जारी रहेगा। हम इस रन के अनुरूप सूचकांकों के सेट को शून्य रन कहते हैं। हमने तुरंत देखा कि प्रत्येक बर्स्ट विवरण के साथ एक शून्य रन जुड़ा हुआ है और प्रत्येक शून्य रन असंयुक्त है। चूंकि हमारे पास है <math>w</math> शून्य रन, और प्रत्येक असंयुक्त है, हमारे पास कुल है <math>n-w</math>सभी शून्य रन में विशिष्ट तत्व। दूसरी ओर हमारे पास है: <math display="block">\begin{align}
n-w = \text{number of zeros in } E &\geqslant  (n - \mathrm{length}(P_1)) + (n - \mathrm{length}(P_2))\\ 
&= 2n - \left ( \mathrm{length}(P_1) +  \mathrm{length}(P_2) \right ) \\
&\geqslant 2n - (n+1) && \mathrm{length}(P_1) + \mathrm{length}(P_2) \leqslant n+1 \\
&= n-1
\end{align}</math>
यह विरोधाभासी है <math>w \geqslant 2.</math><nowiki> इस प्रकार, बर्स्ट त्रुटि विवरण समान हैं.}}</nowiki>}}

उपरोक्त प्रमेय का [[परिणाम]] यह है कि हमारे पास लंबाई के बर्स्ट के लिए दो भिन्न -भिन्न बर्स्ट <math>\tfrac{1}{2}(n+1).</math> विवरण नहीं हो सकते हैं 


==बर्स्ट त्रुटि सुधार के लिए [[चक्रीय कोड]] ==

चक्रीय कोड को इस प्रकार परिभाषित किया गया है: <math>q</math> प्रतीक को <math>\mathbb{F}_q</math> के अवयव के रूप के बारे में सोचें. अब, हम शब्दों को <math>\mathbb{F}_q,</math> से अधिक बहुपद के रूप में सोच सकते हैं जहां किसी शब्द के भिन्न -भिन्न प्रतीक बहुपद के विभिन्न गुणांकों से मेल खाते हैं। चक्रीय कोड को परिभाषित करने के लिए, हम निश्चित बहुपद चुनते हैं, जिसे [[जनरेटर बहुपद]] कहा जाता है। इस चक्रीय कोड के कोडवर्ड वह सभी बहुपद हैं जो इस जनरेटर बहुपद से विभाज्य हैं।

कोडवर्ड डिग्री <math>\leqslant n-1</math> के बहुपद हैं. मान लीजिए कि जनरेटर बहुपद <math>g(x)</math> की डिग्री <math>r</math> है . तथा <math>\leqslant n-1</math> डिग्री के बहुपद जिनसे <math>g(x)</math> विभाज्य होते हैं <math>g(x)</math> को घात <math>\leqslant n-1-r</math> के बहुपदों से गुणा करने से परिणाम प्राप्त होते है . अपने पास <math>q^{n-r}</math> ऐसे बहुपद है. उनमें से प्रत्येक कोडवर्ड से मेल खाता है। इसलिए, <math>k=n-r</math> चक्रीय कोड के लिए उपयोग किये जाते है .

चक्रीय कोड <math>\ell = n-k = r</math> तक की लंबाई के सभी बर्स्ट का पता लगा सकते हैं . हम पश्चात में देखेंगे कि किसी की <math>(n, k)</math> बर्स्ट त्रुटि का पता लगाने की क्षमता कोड ऊपर से <math>\ell \leqslant n-k</math> तक सीमित है। . बर्स्ट त्रुटि का पता लगाने के लिए चक्रीय कोड को इष्टतम माना जाता है क्योंकि वह इस ऊपरी सीमा को पूरा करते हैं:

{{math theorem | name = Theorem (Cyclic burst correction capability) | math_statement = डिग्री के जनरेटर बहुपद के साथ प्रत्येक चक्रीय कोड <math>r</math> लंबाई के सभी विस्फोटों का पता लगा सकता है  <math>\leqslant r.</math>

<nowiki>{{math proof | proof =</nowiki><math>\leqslant r</math> कोडवर्ड के लिए (अर्थात एक बहुपद के लिए जो विभाज्य है <math>g(x)</math>), तब परिणाम कोई कोडवर्ड नहीं होगा (अर्थात संबंधित बहुपद इससे विभाज्य नहीं है) <math>g(x)</math>). यह दिखाने के लिए पर्याप्त है कि लंबाई में कोई उछाल नहीं है <math>\leqslant r</math>से विभाज्य है <math>g(x)</math>.ऐसे फूटने का रूप होता है <math>x^i b(x)</math>, जहाँ <math>\deg(b(x)) < r.</math> इसलिए, <math>b(x)</math>से विभाज्य नहीं है <math>g(x)</math> (क्योंकि पश्चात  वाले के पास डिग्री है<math>r</math>). <math>g(x)</math>से विभाज्य नहीं है <math>x</math> (अन्यथा, सभी कोडवर्ड से प्रारंभ होंगे <math>0</math>). इसलिए, <math>x^i</math>से विभाज्य नहीं है<math>g(x)</math><nowiki> as well.}}</nowiki>
}}

उपरोक्त प्रमाण चक्रीय कोड में बर्स्ट त्रुटि का पता लगाने/सुधार के लिए सरल एल्गोरिदम का सुझाव देता है: संचरित शब्द (अर्थात डिग्री <math>\leqslant n-1</math> का बहुपद) दिया गया है ), जो कि <math>g(x)</math>से विभाजित करने पर इस शब्द के शेषफल की गणना करता और यदि शेषफल शून्य है (अर्थात् यदि शब्द <math>g(x)</math> विभाज्य है ), तो यह वैध कोडवर्ड है। अन्यथा, त्रुटि की रिपोर्ट करें. इस त्रुटि को ठीक करने के लिए, इस शेषफल को प्रेषित शब्द से घटाएँ। घटाव का परिणाम <math>g(x)</math>व से िभाजित होने वाला है (अर्थात यह वैध कोडवर्ड होगा)।                                   

बर्स्ट त्रुटि का पता लगाने पर <math>\ell \leqslant n-k = r</math> की ऊपरी सीमा द्वारा हम जानते हैं कि चक्रीय कोड लंबाई <math>\ell > r</math> के सभी बर्स्ट का पता नहीं लगा सकता है. चूँकि चक्रीय कोड वास्तव में लंबाई <math>> r</math> के अधिकांश बर्स्ट का पता लगा सकते हैं .जिसका कारण यह है कि पता लगाना तभी विफल होता है जब बर्स्ट <math>g(x)</math> विभाज्य हो . द्विआधारी वर्णमाला से अधिक, वहाँ उपस्थित हैं <math>2^{\ell-2}</math> लंबाई का फटना <math>\ell</math>. उनमें से ही <math>2^{\ell-2-r}</math> से विभाज्य हैं <math>g(x)</math>. इसलिए,) लंबाई <math>\ell</math> के सभी बर्स्ट पर समान वितरण मानते हुए पता लगाने में विफलता की संभावना बहुत कम (<math>g(x)</math> है

अब हम चक्रीय कोड के बारे में मौलिक प्रमेय पर विचार करते हैं जो बर्स्ट को भिन्न -भिन्न सहसमुच्चय में वर्गीकृत करके कुशल बर्स्ट-त्रुटि सुधार कोड को डिजाइन करने में सहायता करेगा। 

{{math theorem | name = Theorem (Distinct [[Coset]]s) | math_statement = एक रेखीय कोड<math>C</math>एक<math>\ell</math>-बर्स्ट-एरर-सही कोड यदि लंबाई की सभी बर्स्ट त्रुटियां <math>\leqslant \ell</math> भिन्न -भिन्न  उपसमुच्चय में झूठ बोलें<math>C</math>.

<nowiki>{{math proof | proof =</nowiki><math>\mathbf{e}_1, \mathbf{e}_2</math>लंबाई की भिन्न -भिन्न बर्स्ट त्रुटियाँ हों <math> \leqslant \ell</math> जो कोड के एक ही कोसेट में स्थित हैं <math>C</math>.  Then <math>\mathbf{c} = \mathbf{e}_1 - \mathbf{e}_2</math> कोडवर्ड है. इसलिए, यदि हम प्राप्त करते हैं <math>\mathbf{e}_1,</math> हम इसे या तो डिकोड कर सकते हैं <math>\mathbf{0}</math> or <math>\mathbf{c}</math>. इसके विपरीत, यदि सभी विस्फोट त्रुटियाँ <math>\mathbf{e}_1</math> and <math>\mathbf{e}_2</math> एक ही कोसेट में न रहें, तो प्रत्येक बर्स्ट त्रुटि उसके सिंड्रोम द्वारा निर्धारित होती है। फिर त्रुटि को उसके सिंड्रोम के माध्यम से ठीक किया जा सकता है। इस प्रकार, एक रैखिक कोड <math>C</math> is an <math>\ell</math>-बर्स्ट-त्रुटि-सही कोड यदि और केवल यदि लंबाई की सभी बर्स्ट त्रुटियां<math>\leqslant \ell</math> के भिन्न-भिन्न कोसेट में स्थित हैं<math>C</math><nowiki>.}}</nowiki>}}

{{math theorem | name = Theorem (Burst error codeword classification) | math_statement = मान लीजिये  <math>C</math> एक रेखीय हो <math>\ell</math>-विस्फोट-त्रुटि-सुधार कोड। फिर लंबाई का कोई शून्येतर विस्फोट नहीं <math>\leqslant 2\ell</math>  कोडवर्ड हो सकता है.

{{math proof | proof =<math>c</math> लंबाई में वृद्धि के साथ एक कोडवर्ड बनें <math>\leqslant 2\ell</math>. इस प्रकार इसका पैटर्न है <math>(0,1,u,v,1,0)</math>, जहाँ  <math>u</math> and <math>v</math> लंबाई के शब्द हैं <math>\leqslant \ell -1.</math> इसलिए, शब्द <math>w = (0,1,u,0,0,0)</math> and <math>c-w =  (0,0,0,v,1,0)</math> लंबाई के दो विस्फोट हैं <math> \leqslant \ell</math>. बाइनरी रैखिक कोड के लिए, वे एक ही कोसेट से संबंधित हैं। यह विशिष्ट कोसेट प्रमेय का खंडन करता है, इसलिए लंबाई का कोई गैर-शून्य विस्फोट नहीं होता है<math>\leqslant 2\ell</math>एक कोडवर्ड हो सकता है}}
}}

==बर्स्ट त्रुटि सुधार सीमा==

===बर्स्ट त्रुटि का पता लगाने और सुधार पर ऊपरी सीमा===

ऊपरी सीमा से हमारा तात्पर्य हमारी त्रुटि पता लगाने की क्षमता की सीमा से है जिसे हम कभी भी पार नहीं कर सकते। मान लीजिए कि हम डिज़ाइन बनाना चाहते हैं <math>(n, k)</math> कोड जो लंबाई की सभी बर्स्ट त्रुटियों का पता लगा सकता है <math>\leqslant \ell.</math> पूछने के लिए स्वाभाविक प्रश्न है: दिया गया <math>n</math> और <math>k</math>, अधिकतम क्या है <math>\ell</math> कि हम इससे आगे कभी हासिल नहीं कर सकते? दूसरे शब्दों में, लंबाई की ऊपरी सीमा क्या है <math>\ell</math> हम किसी भी बर्स्ट का पता लगा सकते हैं <math>(n, k)</math> कोड? निम्नलिखित प्रमेय इस प्रश्न का उत्तर प्रदान करता है।

{{math theorem | name = Theorem (Burst error detection ability) | math_statement = किसी की भी बर्स्ट त्रुटि का पता लगाने की क्षमता <math>(n, k)</math> code is <math>\ell \leqslant  n-k.</math>

{{math proof | proof = पहले हम देखते हैं कि एक कोड लंबाई के सभी विस्फोटों का पता लगा सकता है <math>\leqslant  \ell</math> यदि और केवल यदि कोई भी दो कोडवर्ड लंबाई के हिसाब से भिन्न न हों <math>\leqslant  \ell</math>. मान लीजिए कि हमारे पास दो कोड वर्ड हैं <math>\mathbf{c}_1</math> and <math>\mathbf{c}_2</math>जो विस्फोट से भिन्न होता है <math>\mathbf{b}</math> लम्बाई का <math>\leqslant  \ell</math>. प्राप्त करने पर <math>\mathbf{c}_1</math>, हम यह नहीं बता सकते कि प्रेषित शब्द वास्तव में है या नहीं <math>\mathbf{c}_1</math> बिना किसी ट्रांसमिशन त्रुटि के, या चाहे वह हो <math>\mathbf{c}_2</math>बर्स्ट त्रुटि के साथ<math>\mathbf{b}</math>जो प्रसारण के दौरान घटित हुआ। अब, मान लीजिए कि प्रत्येक दो कोडवर्ड की लंबाई में बहुत अधिक अंतर होता है <math>\ell.</math> भले ही प्रेषित कोडवर्ड <math>\mathbf{c}_1</math> विस्फोट की चपेट में आ गया है <math>\mathbf{b}</math> लम्बाई का <math>\ell</math>,यह किसी अन्य वैध कोडवर्ड में परिवर्तित नहीं होगा. इसे प्राप्त करने पर, हम बता सकते हैं कि यह है <math>\mathbf{c}_1</math> विस्फोट के साथ<math>\mathbf{b}.</math> उपरोक्त अवलोकन से, हम जानते हैं कि कोई भी दो कोडवर्ड पहले को साझा नहीं कर सकते हैं <math>n-\ell</math>प्रतीक. कारण यह है कि भले ही वे सभी में भिन्न हों <math>\ell</math> प्रतीक, वे अभी भी लंबाई के आधार पर भिन्न होंगे <math>\ell.</math> इसलिए, कोडवर्ड की संख्या <math>q^k</math>संतुष्ट<math>q^k \leqslant  q^{n-\ell}.</math> को प्रयुक्त करने <math>\log_q</math> दोनों तरफ और पुनर्व्यवस्थित करके, हम इसे देख सकते हैं <math>\ell \leqslant  n-k</math>.}}
}}
अब, हम वही प्रश्न दोहराते हैं किन्तु त्रुटि सुधार के लिए: दिया गया है <math>n</math> और <math>k</math>, लंबाई पर ऊपरी सीमा क्या है <math>\ell</math> बर्स्ट का जिन्हें हम किसी का उपयोग करके ठीक कर सकते हैं <math>(n, k)</math> कोड? निम्नलिखित प्रमेय इस प्रश्न का प्रारंभिक उत्तर प्रदान करता है:

{{math theorem | name = Theorem (Burst error correction ability) | math_statement = किसी की भी बर्स्ट त्रुटि सुधार क्षमता <math>(n, k)</math> कोड संतुष्ट करता है <math>\ell \leqslant  n-k-\log_q (n-\ell)+2</math>

{{math proof | proof = पहले हम देखते हैं कि एक कोड लंबाई के सभी विस्फोटों को ठीक कर सकता है <math>\leqslant  \ell</math>यदि और केवल यदि कोई भी दो कोडवर्ड लंबाई के दो बर्स्ट के योग से भिन्न न हों <math>\leqslant  \ell.</math> मान लीजिए कि दो कोडवर्ड <math>\mathbf{c}_1</math> और <math>\mathbf{c}_2</math> विस्फोट से भिन्न<math>\mathbf{b}_1</math> and <math>\mathbf{b}_2</math> लम्बाई का <math>\leqslant  \ell</math> each.प्राप्त करने पर<math>\mathbf{c}_1</math>विस्फोट से मारा गया<math>\mathbf{b}_1</math>, हम इसकी व्याख्या ऐसे कर सकते हैं जैसे कि यह था <math>\mathbf{c}_2</math> विस्फोट से मारा गया <math>-\mathbf{b}_2</math>. हम यह नहीं बता सकते कि प्रेषित शब्द है या नहीं <math>\mathbf{c}_1</math> or <math>\mathbf{c}_2</math>. अब, मान लीजिए कि प्रत्येक दो कोडवर्ड की लंबाई दो से अधिक भिन्न होती है <math>\ell</math>. तदपि प्रेषित कोडवर्ड <math>\mathbf{c}_1</math> लम्बाई के विस्फोट से मारा जाता है <math>\ell</math>, यह किसी अन्य कोडवर्ड की तरह नहीं दिखने वाला है जो एक और विस्फोट से प्रभावित हुआ है. For each codeword <math>\mathbf{c},</math> मान लीजिये  <math>B(\mathbf{c})</math> से भिन्न सभी शब्दों के समुच्चय को निरूपित करें <math>\mathbf{c}</math> bआप लंबाई का एक विस्फोट <math>\leqslant  \ell.</math> नोटिस जो <math>B(\mathbf{c})</math>सम्मिलित  <math>\mathbf{c}</math>अपने आप। उपरोक्त अवलोकन से, हम जानते हैं कि दो भिन्न-भिन्न कोडवर्ड के लिए <math>\mathbf{c}_i</math> और <math>\mathbf{c}_j, B(\mathbf{c}_i)</math> और <math>B(\mathbf{c}_j)</math> असंयुक्त हैं. अपने पास <math>q^k</math> कोडवर्ड इसलिए हम ऐसा कह सकते हैं<math>q^k |B( \mathbf{c})| \leqslant  q^n</math>. इसके अतिरिक्त, हमारे पास है<math>(n-\ell)q^{\ell-2} \leqslant  |B(\mathbf{c})|</math>. पश्चात वाली असमानता को पहले वाली असमानता से जोड़कर, फिर आधार लेकर <math>q</math>लघुगणक और पुनर्व्यवस्थित करने पर, हमें उपरोक्त प्रमेय प्राप्त होता है।}}
}}
रीगर बाउंड द्वारा सशक्त परिणाम दिया गया है:

{{math theorem | name = Theorem (Rieger bound) | math_statement = यदि  <math>\ell</math>की बर्स्ट त्रुटि सुधार करने की क्षमता है <math>(n, k)</math>रैखिक ब्लॉक कोड, फिर<math>2\ell \leqslant n - k</math>.

{{math proof | proof = कोई भी रैखिक कोड जो लंबाई के किसी भी विस्फोट पैटर्न को सही कर सकता है <math>\leqslant \ell</math>लम्बाई का विस्फोट नहीं हो सकता <math>\leqslant 2\ell</math> एक कोडवर्ड के रूप में. यदि इसकी लम्बाई में वृद्धि होती <math>\leqslant 2\ell</math> एक कोडवर्ड के रूप में, फिर लंबाई का विस्फोट<math>\ell</math> कोडवर्ड को लंबाई के बर्स्ट पैटर्न में बदल सकता है <math>\ell</math>, जिसे लंबाई की बर्स्ट त्रुटि बनाकर भी प्राप्त किया जा सकता है <math>\ell</math> बिल्कुल शून्य कोडवर्ड में. यदि सदिश पहले शून्येतर हैं<math>2\ell</math> प्रतीकों, तो सदिश एक सरणी के विभिन्न उपसमूहों से होने चाहिए ताकि उनका अंतर लंबाई के फटने का कोडवर्ड न हो<math>2\ell</math>. इस शर्त को सुनिश्चित करते हुए, ऐसे उपसमुच्चय की संख्या कम से कम सदिश की संख्या के समान्तर है। इस प्रकार, उपसमुच्चय की संख्या कम से कम होगी<math>q^{2\ell}</math>.इसलिए, हमारे पास कम से कम है <math>2\ell</math> अलग-अलग प्रतीक, अन्यथा, ऐसे दो बहुपदों का अंतर एक कोडवर्ड होगा जो लंबाई के दो विस्फोटों का योग है <math>\leqslant  \ell.</math> इस प्रकार, यह रीगर बाउंड सिद्ध होता है।}}}}

परिभाषा। उपरोक्त रीगर सीमा को प्राप्त करने वाले रैखिक बर्स्ट-त्रुटि-सुधार करने वाले कोड को इष्टतम बर्स्ट-त्रुटि-सुधार करने वाला कोड कहा जाता है।

=== बर्स्ट त्रुटि सुधार पर आगे की सीमाएं ===

एकाधिक चरणबद्ध-बर्स्ट सुधार (एमपीबीसी) के लिए रैखिक ब्लॉक कोड की प्राप्त कोड दर पर से अधिक ऊपरी सीमा होती है। ऐसी सीमा प्रत्येक उपब्लॉक के अंदर अधिकतम सुधार योग्य चक्रीय बर्स्ट लंबाई तक सीमित है, या समकक्ष रूप से प्रत्येक चरण-बर्स्ट के अंदर न्यूनतम त्रुटि मुक्त लंबाई या अंतराल पर बाधा है। यह सीमा, जब एकल बर्स्ट सुधार के लिए बाध्य के विशेष उपस्थितियां में कम हो जाती है, अब्रामसन बाध्य (बर्स्ट -त्रुटि सुधार के लिए हैमिंग बाध्य का परिणाम) है जब चक्रीय बर्स्ट की लंबाई ब्लॉक लंबाई के आधे से कम होती है।<ref name = "Ling, San">Ling, San, and Chaoping Xing. Coding Theory: A First Course. Cambridge, UK: Cambridge UP, 2004. Print</ref>

{{math theorem | name = Theorem (number of bursts) | math_statement = इसके लिए <math>1 \leqslant \ell \leqslant \tfrac{1}{2}(n+1),</math> एक द्विआधारी वर्णमाला पर, वहाँ हैं <math>n2^{\ell-1}+1</math> लंबाई के सदिश<math>n</math> जो लम्बाई के विस्फोट हैं <math>\leqslant \ell</math>.<ref name = "Coding Bounds" />

{{math proof | proof = चूंकि बर्स्ट की लंबाई है<math>\leqslant \tfrac{1}{2}(n+1),</math>विस्फोट के साथ एक अनोखा विस्फोट वर्णन जुड़ा हुआ है। विस्फोट इनमें से किसी पर भी प्रारंभ  हो सकता है <math>n</math> पैटर्न की स्थिति. प्रत्येक पैटर्न की प्रारंभिक होती है<math>1</math> और की लंबाई सम्मलित  है <math>\ell</math>. हम इसे प्रारंभ  होने वाली सभी स्ट्रिंग्स के समूह के रूप में सोच सकते हैं <math>1</math> और लंबाई है <math>\ell</math>. इस प्रकार, कुल हैं<math>2^{\ell-1}</math>ऐसे पैटर्न संभव हैं, और कुल <math>n2^{\ell-1}</math>लंबाई का फटना<math>\leqslant \ell.</math>यदि हम सर्व-शून्य विस्फोट को सम्मिलित  करते हैं, तो हमारे पास है <math>n2^{\ell-1}+1</math> सदिश लंबाई के विस्फोट का प्रतिनिधित्व करते हैं <math>\leqslant \ell.</math>}}}}

{{math theorem | name = Theorem (Bound on the number of codewords) | math_statement = यदि  <math>1 \leqslant \ell \leqslant \tfrac{1}{2}(n+1),</math>बाइनरी <math>\ell</math>-विस्फोट त्रुटि सुधार कोड में अधिकतम है <math>2^n/(n2^{\ell-1}+1)</math> कूटशब्द.

{{math proof | proof = Since <math>\ell \leqslant \tfrac{1}{2}(n+1)</math>, हम जानते हैं कि वहाँ हैं <math>n 2^{\ell-1}+1</math>लंबाई का फटना<math>\leqslant \ell</math>. कहो कोड है <math>M</math> कोडवर्ड, तो वहाँ हैं <math>Mn2^{\ell-1}</math>ऐसे कोडवर्ड जो लंबाई की दृष्टि से कोडवर्ड से भिन्न होते हैं <math>\leqslant \ell</math>.हरेक <math>M</math> शब्द भिन्न-भिन्न होने चाहिए, अन्यथा कोड में दूरी होगी<math>< 1</math>. इसलिए, <math>M(2^{\ell-1}+1) \leqslant 2^n</math> तात्पर्य <math>M \leqslant 2^n/(n2^{\ell-1}+1).</math>}}}}

{{math theorem | name = Theorem (Abramson's bounds) | math_statement = यदि  <math>1 \leqslant \ell \leqslant \tfrac{1}{2}(n+1)</math> एक बाइनरी है [[रैखिक कोड|रैखिक]] <math>(n,k), \ell</math>-बर्स्ट त्रुटि सुधार कोड, इसकी ब्लॉक-लंबाई को संतुष्ट करना होगा:<math display="block">n \leqslant 2^{n-k-\ell+1} -1.</math>

{{math proof | proof = For a linear <math>(n,k)</math> कोड, वहाँ हैं <math>2^k</math> कोडवर्ड हमारे पिछले परिणाम से, हम यह जानते हैं 
<math display="block">2^k \leqslant \frac{2^n}{n2^{\ell-1}+1}.</math>
भिन्न <math>n</math>, we get <math>n \leqslant 2^{n-k-\ell+1}-2^{-\ell+1}</math>.तब से <math>\ell \geqslant 1</math> and <math>n</math>एक पूर्णांक होना चाहिए, हमारे पास है <math>n \leqslant 2^{n-k-\ell+1}-1</math>.}}}}

टिप्पणी। <math>r = n - k</math> कोड की अतिरेक कहा जाता है और अब्रामसन की सीमा के लिए वैकल्पिक सूत्रीकरण में है <math>r \geqslant \lceil \log_2(n+1) \rceil + \ell -1.</math>


==अग्नि कोड<ref name = "Ling, San" /><ref name = "Moon, Todd">Moon, Todd K. Error Correction Coding: Mathematical Methods and Algorithms. Hoboken, NJ: Wiley-Interscience, 2005. Print</ref><ref name = "Lin, Shu">Lin, Shu, and Daniel J. Costello. Error Control Coding: Fundamentals and Applications. Upper Saddle River, NJ: Pearson-Prentice Hall, 2004. Print</ref>==
जबकि सामान्यतः चक्रीय कोड बर्स्ट त्रुटियों का पता लगाने के लिए शक्तिशाली उपकरण होते हैं, अब हम फायर कोड नामक बाइनरी चक्रीय कोड के वर्ग पर विचार करते हैं, जिसमें अच्छी एकल बर्स्ट त्रुटि सुधार क्षमताएं होती हैं। एकल बर्स्ट से, लंबाई <math>\ell</math> के बारे में कहें , हमारा अर्थ है कि प्राप्त कोडवर्ड में उपस्थित सभी त्रुटियां निश्चित अवधि के अंदर होती हैं <math>\ell</math> अंक है .

मान लीजिये <math>p(x)</math> डिग्री का अपरिवर्तनीय बहुपद बनें <math>m</math> ऊपर <math>\mathbb{F}_2</math>, और जाने <math>p</math> की अवधि हो <math>p(x)</math>. की अवधि <math>p(x)</math>, और वास्तव में किसी भी बहुपद को सबसे कम धनात्मक पूर्णांक के रूप में परिभाषित किया गया है <math>r</math> ऐसा है कि <math>p(x) |x^r - 1.</math> होने देना <math>\ell</math> धनात्मक पूर्णांक <math>\ell \leqslant m</math> और <math>2\ell -1</math> संतोषजनक हो तथा <math>p</math> से विभाज्य नहीं है , जहाँ <math>p</math> की अवधि है <math>p(x)</math>. अग्नि संहिता को परिभाषित करें <math>G</math> निम्नलिखित जनरेटर बहुपद द्वारा:
<math display="block">g(x) = \left (x^{2\ell -1} + 1 \right )p(x).</math>
हम वो दिखाएंगे <math>G</math> <math>\ell</math>-बर्स्ट -त्रुटि सुधार कोड।

{{math theorem | name = Lemma 1 | math_statement = <math>\gcd \left (p(x), x^{2\ell -1} + 1 \right ) = 1.</math>

{{math proof | proof = Let <math>d(x)</math> दो बहुपदों का सबसे बड़ा सामान्य भाजक बनें। तब से <math>p(x)</math> अपरिवर्तनीय है, <math>\deg(d(x)) = 0</math> या <math>\deg(p(x))</math>.मान लीजिए <math>\deg(d(x)) \neq 0,</math> तब <math>p(x) = c d(x)</math> for कुछ स्थिर<math>c</math>. किन्तु, <math>(1/c)p(x)</math> का भाजक है<math>x^{2\ell -1}+1</math> तब से<math>d(x)</math> का भाजक है<math>x^{2\ell -1}+1</math>.किन्तु यह हमारी धारणा का खंडन करता है<math>p(x)</math> विभाजित नहीं करता <math>x^{2\ell -1}+1.</math> यद्यपि, <math>\deg(d(x)) = 0,</math> प्रमेयिका सिद्ध करना.}}}}

{{math theorem | name = Lemma 2 | math_statement = यदि <math>p(x)</math>काल का एक बहुपद है<math>p</math>, तब <math>p(x)|x^k-1</math> यदि और केवल यदि<math>p|k.</math>

{{math proof | proof = यदि  <math>p|k</math>, तब <math>x^k-1 = (x^p-1)(1 + x^p + x^{2p} + \dots + x^{k/p})</math>. इस प्रकार, <math>p(x)|x^k-1.</math>
{{pb}}
अब मान लीजिए <math>p(x) | x^k-1</math>. तब , <math>k \geqslant p</math>. हम वो दिखाते हैं<math>k</math>से विभाज्य है <math>p</math> पर प्रेरण द्वारा  <math>k</math>. आधार स्तिथि <math>k = p</math>अनुसरण करता है। इसलिए, मान लीजिए<math>k > p</math>.हम वह जानते हैं<math>p(x)</math> दोनों को विभाजित करता है (क्योंकि इसमें आवर्त है<math>p</math>) <math display="block">x^p -1 = (x-1) \left (1 + x + \dots + x^{p-1} \right ) \quad  \text{and}  \quad x^k - 1 = (x-1) \left (1 + x + \dots + x^{k-1} \right ).</math> किन्तु  <math>p(x)</math> अपरिवर्तनीय है, इसलिए इसे दोनों को विभाजित करना होगा <math>(1 + x + \dots + x^{p-1})</math> and <math>(1 + x + \dots + x^{k-1})</math>; इस प्रकार, यह अंतिम दो बहुपदों के अंतर को भी विभाजित करता है, <math>x^p(1 + x + \dots + x^{p-k-1})</math>. फिर, यह उसका अनुसरण करता है  <math>p(x)</math> divides <math>(1 + x + \cdots + x^{p-k-1})</math>. अंत में, यह भी विभाजित होता है:<math>x^{k-p}-1 = (x-1)(1 + x + \dots + x^{p-k-1})</math>.प्रेरण परिकल्पना द्वारा,<math>p | k-p</math>, तब  <math>p | k</math>.

लेम्मा 2 का एक परिणाम यह है कि तब से <math>p(x) = x^p - 1</math>अवधि है <math>p</math>, तब <math>p(x)</math> विभाजित<math>x^k-1</math> यदि और केवल यदि <math>p|k</math>.}}}}

{{math theorem | math_statement = फायर कोड है<math>\ell</math>-विस्फोट त्रुटि को सुधारना<ref name = "Moon, Todd" /><ref name = "Lin, Shu" />}}

यदि हम यह दिखा सकें कि लंबाई के सभी बर्स्ट <math>\ell</math> या कम भिन्न -भिन्न [[ सह समुच्चय |सह समुच्चय]] में होते हैं, हम उन्हें [[ कोसेट नेता |सहसमुच्चय लीडर]] के रूप में उपयोग कर सकते हैं जो सुधार योग्य त्रुटि पैटर्न बनाते हैं। कारण सरल है: हम जानते हैं कि प्रत्येक सहसमुच्चय में अद्वितीय [[सिंड्रोम डिकोडिंग]] जुड़ी होती है, और यदि भिन्न -भिन्न लंबाई के सभी बर्स्ट भिन्न -भिन्न सहसमुच्चय में होते हैं, तो सभी में अद्वितीय सिंड्रोम होते हैं, जिससे त्रुटि सुधार की सुविधा मिलती है।

===प्रमेय का प्रमाण===
मान लीजिए कि <math>x^i a(x)</math> और <math>x^j b(x)</math> डिग्री <math>\ell_1-1</math> और <math>\ell_2-1</math> के साथ बहुपद हैं, जो क्रमशः <math>\ell_1, \ell_2 \leqslant \ell.</math> के साथ लंबाई <math>\ell_1</math> और <math>\ell_2</math> के विस्फोट का प्रतिनिधित्व करते हैं, पूर्णांक <math>i, j</math> प्रारंभिक का प्रतिनिधित्व करते हैं बर्स्ट की स्थिति, और कोड की ब्लॉक लंबाई से कम होते हैं। विरोधाभास के लिए, यह मान लें <math>x^i a(x)</math> और <math>x^j b(x)</math> ही सहसमुच्चय में हैं. तब, <math>v(x) = x^i a(x) + x^j b(x)</math> वैध कोडवर्ड है (क्योंकि दोनों पद ही सहसमुच्चय में हैं)। व्यापकता की हानि के बिना, <math>i \leqslant j</math>.चुनें [[विभाजन प्रमेय]] द्वारा हम लिख सकते हैं: पूर्णांकों <math>g</math> और <math>r, 0 \leqslant r < 2\ell -1</math> के लिए <math>j-i = g(2\ell -1)+r,</math>| हम बहुपद को फिर से लिखते हैं <math>v(x)</math> निम्नलिखित नुसार:
<math display="block">v(x) = x^ia(x) + x^{i + g(2\ell -1) + r} =  x^ia(x) + x^{i + g(2\ell -1) + r} + 2x^{i+r}b(x) = x^i \left (a(x) + x^b b(x) \right ) + x^{i+r}b(x) \left (x^{g(2\ell -1)}+1 \right )</math>

ध्यान दें कि दूसरे परिवर्तन में, हमने <math>2x^{i+r}b(x)</math> शब्द प्रस्तुत किया . हमें ऐसा करने की अनुमति है, क्योंकि फायर कोड <math>\mathbb{F}_2</math> क्रियान्वित हैं . और हमारी धारणा से, <math>v(x)</math> वैध कोडवर्ड है, तथा इस प्रकार, इसका गुणज <math>g(x)</math> होना चाहिए . जैसा कि पहले उल्लेख किया गया है, कि <math>g(x)</math>कारकों के पश्चात <math>v(x)</math>से अपेक्षाकृत प्रमुख हैं, जो कि <math>x^{2\ell -1} + 1</math> से विभाज्य होना चाहिए . <math>v(x)</math> के लिए व्युत्पन्न अंतिम अभिव्यक्ति को समीप से देख रहे हैं हम उस पर ध्यान देते हैं कि <math>x^{g(2\ell -1)} + 1</math>, <math>x^{2\ell -1} + 1</math> (लेम्मा 2 के परिणाम द्वारा ) से विभाज्य है। इसलिए, <math>a(x) + x^bb(x)</math> या <math>x^{2\ell -1} + 1</math> तो विभाज्य <math>0</math> है विभाजन प्रमेय को दोबारा प्रयुक्त करने पर, हम देखते हैं कि <math>\delta</math> वाला बहुपद <math>d(x)</math> पर इस प्रकार उपस्थित है 
<math display="block">a(x) + x^b b(x) = d(x) (x^{2\ell -1}+1)</math>
तब हम लिख सकते हैं:
<math display="block">\begin{align}
\delta + 2\ell  -1 & = \deg \left (d(x) \left (x^{2\ell -1}+1 \right ) \right ) \\
&= \deg \left (a(x) + x^b b(x) \right ) \\
&= \deg \left (x^b b(x) \right ) && \deg(a(x)) = \ell_1 - 1 < 2\ell -1 \\
&= b + \ell_2 -1
\end{align}</math>
दोनों पक्षों की डिग्री को समान करने से हमें <math>b = 2\ell  - \ell_2 + \delta.</math> प्राप्त होता है तब से <math>\ell_1, \ell_2 \leqslant \ell</math> हम निष्कर्ष निकाल सकते हैं <math>b \geqslant \ell + \delta,</math> जो ये दर्शाता हे <math>b > \ell -1</math> और <math>b > \delta</math>. ध्यान दें कि विस्तार में:

<math display="block">a(x) + x^bb(x) = 1 + a_1x + a_2x^2 + \dots + x^{\ell_1-1} + x^b \left (1 + b_1x + b_2x^2 + \dots + x^{\ell_2-1} \right ). </math>
शब्द <math>x^b</math> प्रकट होता है, किन्तु <math>\delta < b < 2\ell -1</math> के पश्चात से , परिणामी अभिव्यक्ति <math>d(x)(x^{2\ell -1} + 1)</math> में <math>x^b</math> सम्मिलित नहीं है, इसलिए <math>d(x) = 0</math> और पश्चात में <math>a(x) + x^b b(x) = 0.</math> इसके लिए इसकी आवश्यकता है कि <math>b = 0</math>, और <math>a(x) = b(x)</math>. हम <math>b = 0,</math> अर्थात {{nowrap|<math>j-i = g(2\ell -1)</math>.}} को प्रतिबिंबित करने के लिए <math>j-i</math> के अपने विभाजन को <math>g(2\ell -1)</math> तक संशोधित कर सकते हैं। <math>v(x)</math> में वापस प्रतिस्थापित करने पर हमें प्राप्त होता है,,
<math display="block">v(x) = x^i b(x) \left (x^{j-1}+1 \right ).</math>

तब से <math>\deg(b(x)) = \ell_2-1 < \ell</math>, अपने पास <math>\deg(b(x)) < \deg(p(x)) = m</math>. किन्तु <math>p(x)</math> इसलिए, अपरिवर्तनीय है <math>b(x)</math> और <math>p(x)</math> अपेक्षाकृत प्रधान होना चाहिए। तब से <math>v(x)</math> कोडवर्ड है, <math>x^{j-1}+1</math> से विभाज्य होना चाहिए <math>p(x)</math>, क्योंकि इसे विभाज्य नहीं किया जा सकता <math>x^{2\ell -1} + 1</math>. इसलिए, <math>j-i</math> का गुणज होना चाहिए <math>p</math>. किन्तु इसका गुणज भी होना चाहिए <math>2\ell -1</math>, जिसका अर्थ है कि यह का गुणज होना चाहिए <math>n = \text{lcm}(2\ell -1,p)</math> किन्तु वह बिल्कुल कोड की ब्लॉक-लंबाई है। इसलिए, <math>j-i</math> का गुणज नहीं हो सकता <math>n</math> चूँकि वह दोनों इससे कम हैं <math>n</math>. इस प्रकार, हमारी धारणा <math>v(x)</math> कोडवर्ड होना गलत है, और इसलिए <math>x^i a(x)</math> और <math>x^j b(x)</math> अद्वितीय सिंड्रोम के साथ भिन्न -भिन्न सहसमुच्चय में हैं, और इसलिए सुधार योग्य हैं।

===उदाहरण: फायर कोड को सही करने में 5-बर्स्ट त्रुटि===
उपरोक्त अनुभाग में प्रस्तुत सिद्धांत के साथ, के निर्माण पर विचार करें <math>5</math>-फ़ायर कोड को सही करने में बर्स्ट त्रुटि। याद रखें कि फायर कोड बनाने के लिए, हमें अपरिवर्तनीय बहुपद की आवश्यकता होती है <math>p(x)</math>, पूर्णांक <math>\ell</math>, हमारे कोड की बर्स्ट त्रुटि सुधार क्षमता का प्रतिनिधित्व करता है, और हमें उस संपत्ति को संतुष्ट करने की आवश्यकता है
<math>2\ell -1</math> की अवधि से विभाज्य नहीं है <math>p(x)</math>. इन आवश्यकताओं को ध्यान में रखते हुए, अपरिवर्तनीय बहुपद पर विचार करें <math>p(x) = 1 + x^2 + x^5</math>, और जाने <math>\ell = 5</math>. तब से <math>p(x)</math> आदिम बहुपद है, इसका आवर्त है <math>2^5 - 1 = 31</math>. हम इसकी पुष्टि करते हैं <math>2\ell - 1 = 9</math> से विभाज्य नहीं है <math>31</math>. इस प्रकार,

<math display="block">g(x) = (x^9+1) \left (1 + x^2 + x^5 \right ) = 1 + x^2 + x^5 + x^9 + x^{11} + x^{14}</math>


इस प्रकार फायर कोड जनरेटर है. हम न्यूनतम समापवर्त्य का मूल्यांकन करके कोड की ब्लॉक-लंबाई की गणना कर सकते हैं <math>p</math> और <math>2\ell -1</math>. दूसरे शब्दों में, <math>n = \text{lcm}(9,31) = 279</math>. इस प्रकार, उपरोक्त फायर कोड चक्रीय कोड है जो लंबाई के किसी भी बर्स्ट को ठीक करने में सक्षम है <math>5</math> या कम।

==बाइनरी रीड-सोलोमन कोड==
कोड के कुछ वर्ग , जैसे रीड-सोलोमन त्रुटि सुधार|रीड-सोलोमन, बाइनरी से बड़े वर्णमाला आकार पर काम करते हैं। यह संपत्ति ऐसे कोड को शक्तिशाली बर्स्ट त्रुटि सुधार क्षमताएं प्रदान करती है। <math>\mathbb{F}_{2^m}</math>उस कोड पर विचार करें जिस पर कार्य चल रहा है . वर्णमाला <math>m</math> के प्रत्येक प्रतीक को <math>m</math> बिट्स द्वारा दर्शाया जा सकता है? यदि <math>C</math> <math>\mathbb{F}_{2^m}</math> के ऊपर <math>(n,k)</math> रीड-सोलोमन कोड ख़त्म है, हम <math>C</math> को <math>\mathbb{F}_{2}</math> के ऊपर <math>[mn,mk]_2</math> कोड के रूप में सोच सकते हैं .

बर्स्ट त्रुटि सुधार के लिए ऐसे कोड शक्तिशाली होने का कारण यह है कि प्रत्येक प्रतीक <math>m</math> बिट्स का प्रतिनिधित्व किया जाता है , और सामान्यतः , यह अप्रासंगिक है कि उनमें से कितने हैं <math>m</math> बिट्स ग़लत हैं; चाहे बिट, या सभी <math>m</math> बिट्स में त्रुटियाँ हैं, डिकोडिंग परिप्रेक्ष्य से यह अभी भी एकल प्रतीक त्रुटि है। दूसरे शब्दों में, चूंकि क्लस्टर में बर्स्ट त्रुटियां होती हैं, इसलिए एकल प्रतीक त्रुटि में अनेक बाइनरी त्रुटियों के योगदान की प्रबल संभावना होती है।

ध्यान दें कि बर्स्ट <math>(m+1)</math> त्रुटियाँ अधिकतम प्रभावित कर सकती हैं <math>2</math> प्रतीकों, और का बर्स्ट <math>2m + 1</math> अधिक से अधिक प्रभावित कर सकता है <math>3</math> प्रतीक. फिर, बर्स्ट <math>tm+1</math> अधिक से अधिक प्रभावित कर सकता है <math>t + 1</math> प्रतीक; इसका तात्पर्य यह है कि ए <math>t</math>-प्रतीक-त्रुटि सुधार कोड अधिकतम लंबाई के बर्स्ट को ठीक कर सकता है <math>(t-1)m+1</math>.

सामान्यतः , a <math>t</math>-रीड-सोलोमन कोड को सही करने में त्रुटि <math>\mathbb{F}_{2^m}</math> के किसी भी संयोजन को ठीक कर सकता है
<math display="block">\frac{t}{1+\lfloor (l+m-2)/m \rfloor}</math>
या लंबाई के कम बर्स्ट <math>l</math>, सही करने में सक्षम होने के शीर्ष पर <math>t</math>-यादृच्छिक सबसे व्यर्थ स्थिति त्रुटियाँ।

===बाइनरी आरएस कोड का उदाहरण===
मान लीजिये <math>G</math> हो <math>[255,223,33]</math> आरएस कोड ख़त्म <math>\mathbb{F}_{2^8}</math>. इस कोड को [[नासा]] ने अपने [[कैसिनी-हुय्गेंस]] अंतरिक्ष यान में नियोजित किया था।<ref>{{cite web |url=http://quest.arc.nasa.gov/saturn/qa/cassini/Error_correction.txt |title= |website=quest.arc.nasa.gov |archive-url=https://web.archive.org/web/20120627022807/http://quest.arc.nasa.gov/saturn/qa/cassini/Error_correction.txt |archive-date=2012-06-27}}</ref> यह ठीक करने में सक्षम है <math>\lfloor 33/2 \rfloor = 16</math> प्रतीक त्रुटियाँ. अब हम बाइनरी आरएस कोड बनाते हैं <math>G'</math> से <math>G</math>. प्रत्येक चिन्ह का प्रयोग करके लिखा जायेगा <math>\lceil \log_2(255) \rceil = 8</math> बिट्स इसलिए, बाइनरी आरएस कोड होगा <math>[2040,1784,33]_2</math> इसके मापदंड के रूप में। यह लंबाई के किसी भी बर्स्ट को ठीक करने में सक्षम है <math>l = 121</math>.

==इंटरलीव्ड कोड==
इंटरलीविंग का उपयोग कनवल्शनल कोड को यादृच्छिक त्रुटि सुधारकों से बर्स्ट त्रुटि सुधारकों में परिवर्तित करने के लिए किया जाता है। इंटरलीव्ड कोड के उपयोग के पीछे मूल विचार ट्रांसमीटर पर प्रतीकों को मिलाना है। इससे प्राप्त त्रुटियों के बर्स्ट का यादृच्छिककरण होता है जो निकट स्थित होते हैं और फिर हम यादृच्छिक चैनल के लिए विश्लेषण प्रयुक्त कर सकते हैं। इस प्रकार, ट्रांसमीटर पर इंटरलीवर द्वारा किया जाने वाला मुख्य कार्य इनपुट प्रतीक अनुक्रम को परिवर्तित करना है। रिसीवर पर, डिइंटरलीवर ट्रांसमीटर पर मूल अपरिवर्तित अनुक्रम को वापस पाने के लिए प्राप्त अनुक्रम को परिवर्तित कर देगा।

===इंटरलीवर की बर्स्ट त्रुटि सुधार क्षमता                                                  ===
[[File:Row_and_column_major_order.svg|thumb|upright|पंक्ति और स्तंभ-प्रमुख क्रम का चित्रण]]
{{math theorem | math_statement = यदि बर्स्ट एरर को कुछ कोड की सही करने की क्षमता है <math>\ell,</math> फिर बर्स्ट त्रुटि को ठीक करने की क्षमता <math>\lambda</math>-वे इंटरलीव है <math>\lambda \ell.</math>

{{math proof | proof = मान लीजिए कि हमारे पास एक <math>(n, k)</math> कोड जो लंबाई के सभी विस्फोटों को ठीक कर सकता है <math>\leqslant \ell.</math> [[फॉरवर्ड त्रुटि सुधार या इंटरलीविंग|इंटरलीविंग]] हमें प्रदान कर सकता है<math>(\lambda n, \lambda k)</math> कोड जो लंबाई के सभी विस्फोटों को ठीक कर सकता है <math>\leqslant \lambda \ell,</math>किसी भी दिए गए के लिए<math>\lambda</math>.यदि हम इंटरलीविंग का उपयोग करके अपनी इच्छानुसार लंबाई के संदेश को एन्कोड करना चाहते हैं, तो पहले हम इसे लंबाई के ब्लॉक में विभाजित करते हैं <math>\lambda k</math>.हम लिखते हैं<math>\lambda k</math> प्रत्येक ब्लॉक की प्रविष्टियाँ a <math>\lambda \times k</math> पंक्ति-प्रमुख क्रम का उपयोग कर मैट्रिक्स। फिर, हम प्रत्येक पंक्ति का उपयोग करके एन्कोड करते हैं <math>(n, k)</math> कोड. हमें जो मिलेगा वह है a <math>\lambda \times n</math> आव्यूह। अब, इस आव्यूह को कॉलम-प्रमुख क्रम में पढ़ा और प्रसारित किया जाता है। विधि यह है कि यदि लम्बाई का विस्फोट होता है<math>h</math> प्रेषित शब्द में, तो प्रत्येक पंक्ति में लगभग शामिल होगा<math>\tfrac{h}{\lambda}</math>लगातार त्रुटियाँ (अधिक विशेष रूप से, प्रत्येक पंक्ति में कम से कम लंबाई का विस्तार होगा <math>\lfloor\tfrac{h}{\lambda}\rfloor</math>और अधिक से अधिक<math>\lceil\tfrac{h}{\lambda}\rceil</math>).यदि <math>h \leqslant \lambda \ell,</math> तब <math>\tfrac{h}{\lambda} \leqslant \ell</math> और यह <math>(n, k)</math>कोड प्रत्येक पंक्ति को सही कर सकता है। इसलिए, इंटरलीव्ड <math>(\lambda n, \lambda k)</math> कोड लंबाई के विस्फोट को ठीक कर सकता है <math>h</math>.इसके विपरीत, यदि<math>h > \lambda \ell,</math>तो कम से कम एक पंक्ति में इससे अधिक होंगे <math>\tfrac{h}{\lambda}</math>निरंतर त्रुटियाँ, और <math>(n, k)</math>कोड उन्हें ठीक करने में विफल हो सकता है। इसलिए, इंटरलीव्ड की त्रुटि सुधार क्षमता<math>(\lambda n, \lambda k)</math> कोड बिल्कुल सही है<math>\lambda \ell.</math> इंटरलीव्ड कोड की बीईसी दक्षता मूल के समान ही रहती है <math>(n, k)</math> कोड. यह सच है क्योंकि:
<math display="block">\frac{2\lambda \ell}{\lambda n - \lambda k}= \frac{2\ell}{n-k}</math>}}
}}

===ब्लॉक इंटरलीवर===
नीचे दिया गया चित्र 4 द्वारा 3 इंटरलीवर दिखाता है।
[[File:Block,Interleaver,Example.jpg|framed|center|ब्लॉक इंटरलीवर का उदाहरण]]उपरोक्त इंटरलीवर को ब्लॉक इंटरलीवर कहा जाता है। यहां, इनपुट प्रतीकों को पंक्तियों में क्रमिक रूप से लिखा जाता है और आउटपुट प्रतीकों को स्तम्भ को क्रमिक रूप से पढ़कर प्राप्त किया जाता है। इस प्रकार, यह इस रूप में है <math>M \times N</math> सरणी. सामान्यतः , <math>N</math> कोडवर्ड की लंबाई है.

ब्लॉक इंटरलीवर की क्षमता: के लिए <math>M \times N</math> ब्लॉक इंटरलीवर और लंबाई का फटना <math>\ell,</math> त्रुटियों की संख्या की ऊपरी सीमा है <math>\tfrac{\ell}{M}.</math> यह इस तथ्य से स्पष्ट है कि हम आउटपुट को स्तम्भ के अनुसार पढ़ रहे हैं और पंक्तियों की संख्या है <math>M</math>. उपरोक्त प्रमेय के अनुसार त्रुटि सुधार क्षमता तक <math>t,</math> अनुमत अधिकतम बर्स्ट लंबाई है <math>Mt.</math> की बर्स्ट लंबाई के लिए <math>Mt+1</math>, डिकोडर विफल हो सकता है।

ब्लॉक इंटरलीवर की दक्षता (<math>\gamma</math>): यह बर्स्ट लंबाई का अनुपात लेकर पाया जाता है जहां डिकोडर इंटरलीवर मेमोरी में विफल हो सकता है। इस प्रकार, हम सूत्रीकरण कर सकते हैं <math>\gamma</math> जैसा
<math display="block">\gamma=\frac{Mt+1}{MN} \approx \frac{t}{N}.</math>
ब्लॉक इंटरलीवर की कमियाँ: जैसा कि चित्र से स्पष्ट है, स्तम्भ क्रमिक रूप से पढ़े जाते हैं, रिसीवर पूर्ण संदेश प्राप्त करने के पश्चात ही एकल पंक्ति की व्याख्या कर सकता है, उससे पहले नहीं। साथ ही, प्राप्त प्रतीकों को संग्रहीत करने के लिए रिसीवर को काफी मात्रा में मेमोरी की आवश्यकता होती है और उसे पूरा संदेश संग्रहीत करना होता है। इस प्रकार, ये कारक दो कमियों को उत्पन्न करते हैं, जिसमे पहला है विलंबता और दूसरा है संग्रहण (काफी बड़ी मात्रा में मेमोरी)। नीचे वर्णित कनवल्शनल इंटरलीवर का उपयोग करके इन कमियों से बचा जा सकता है।

===कन्वेंशनल इंटरलीवर                      ===
क्रॉस इंटरलीवर प्रकार का मल्टीप्लेक्सर-डेमल्टीप्लेक्सर प्रणाली है। इस प्रणाली में, लंबाई को उत्तरोत्तर बढ़ाने के लिए विलंब रेखाओं का उपयोग किया जाता है। विलंब रेखा मूल रूप से इलेक्ट्रॉनिक परिपथ है जिसका उपयोग सिग्नल को निश्चित समय अवधि तक विलंबित करने के लिए किया जाता है। होने देना <math>n</math> विलंब रेखाओं की संख्या हो और <math>d</math> प्रत्येक विलंब रेखा द्वारा प्रस्तुत प्रतीकों की संख्या हो। इस प्रकार, निरंतर इनपुट के बीच भिन्नता = <math>nd</math> प्रतीक. कोडवर्ड की लंबाई बताएं <math>\leqslant n.</math> इस प्रकार, इनपुट कोडवर्ड में प्रत्येक प्रतीक भिन्न विलंब रेखा पर होगा। लंबाई की बर्स्ट त्रुटि दें <math>\ell</math> घटित होना। चूँकि <math>nd,</math> क्रमागत प्रतीकों के बीच पृथक्करण है डीइंटरलीव्ड आउटपुट में त्रुटियों की संख्या <math>\tfrac{\ell}{nd+1}.</math>हो सकती है उपरोक्त प्रमेय के अनुसार, त्रुटि सुधार क्षमता <math>t</math> तक, अनुमत अधिकतम बर्स्ट लंबाई <math>(nd+1)(t-1).</math> है तथा इसकी बर्स्ट लंबाई के लिए <math>(nd+1) (t-1) + 1,</math> डिकोडर विफल हो सकता है.
[[File:Convolutional,Interleaver,Example.jpg|framed|center|कन्वेल्यूशनल इंटरलीवर का उदाहरण]]
[[File:Deinterleaver,Example.jpg|framed|डिइंटरलीवर का उदाहरण]]क्रॉस इंटरलीवर की दक्षता (<math>\gamma</math>): यह बर्स्ट लंबाई के अनुपात को लेकर पाया जाता है जहां डिकोडर इंटरलीवर मेमोरी में विफल हो सकता है। इस उपस्थितियों में, इंटरलीवर की मेमोरी की गणना इस प्रकार की जा सकती है
<math display="block">(0 + 1 + 2 + 3 + \cdots + (n-1))d = \frac{n(n-1)}{2} d.</math>
इस प्रकार, हम <math>\gamma</math> का सूत्रीकरण कर सकते हैं निम्नलिखित नुसार:
<math display="block">\gamma = \frac{(nd+1)(t-1)+1}{\frac{n(n-1)}{2}d}.</math>
क्रॉस इंटरलीवर का प्रदर्शन: जैसा कि उपरोक्त इंटरलीवर चित्र में दिखाया गया है, आउटपुट प्रत्येक विलंब रेखा के अंत में उत्पन्न विकर्ण प्रतीकों के अतिरिक्त कुछ नहीं है। इस उपस्थितियां में, जब इनपुट मल्टीप्लेक्सर स्विच लगभग आधा स्विचिंग पूरा कर लेता है, तो हम रिसीवर पर पहली पंक्ति पढ़ सकते हैं। इस प्रकार, हमें पहली पंक्ति को पढ़ने के लिए रिसीवर पर अधिकतम लगभग आधा संदेश संग्रहीत करने की आवश्यकता है। इससे संग्रहण की आवश्यकता आधे से भी कम हो जाती है। चूँकि अब पहली पंक्ति को पढ़ने के लिए केवल आधे संदेश की आवश्यकता होती है, विलंबता भी आधी कम हो जाती है जो ब्लॉक इंटरलीवर की तुलना में अच्छा सुधार है। इस प्रकार, कुल इंटरलीवर मेमोरी ट्रांसमीटर और रिसीवर के बीच विभाजित हो जाती है।

==अनुप्रयोग                        ==

=== कॉम्पैक्ट डिस्क                                                         ===

त्रुटि सुधार कोड के बिना, डिजिटल ऑडियो तकनीकी रूप से संभव नहीं होगा।<ref name = "Algebraic Error Control Codes">Algebraic Error Control Codes (Autumn 2012) – Handouts from Stanford University</ref> रीड-सोलोमन त्रुटि सुधार|रीड-सोलोमन कोड एकल बिट त्रुटि वाले दूषित प्रतीक को उतनी ही सरलता से ठीक कर सकते हैं जितनी सरलता से यह सभी बिट गलत वाले प्रतीक को ठीक कर सकता है। यह आरएस कोड को बर्स्ट त्रुटियों को ठीक करने के लिए विशेष रूप से उपयुक्त बनाता है।<ref name = "Lin, Shu" /> अब तक, आरएस कोड का सबसे सामान्य अनुप्रयोग कॉम्पैक्ट डिस्क में है। आरएस कोड द्वारा प्रदान की गई मूलभूत त्रुटि सुधार के अलावा, डिस्क पर खरोंच के कारण होने वाली बर्स्ट त्रुटियों से सुरक्षा क्रॉस इंटरलीवर द्वारा प्रदान की जाती है।<ref name = "Ling, San" />

वर्तमान कॉम्पैक्ट डिस्क डिजिटल ऑडियो प्रणाली नीदरलैंड के एन. वी. फिलिप्स और जापान के सोनी कॉरपोरेशन (1979 में हस्ताक्षरित समझौते) द्वारा विकसित किया गया था।

कॉम्पैक्ट डिस्क में स्पष्ट प्लास्टिक कोटिंग के साथ लेपित 120 मिमी एल्युमिनाइज्ड डिस्क होती है, जिसमें सर्पिल ट्रैक होता है, जिसकी लंबाई लगभग 5 किमी होती है, जिसे ~ 0.8 माइक्रोमीटर तरंग दैर्ध्य के लेजर द्वारा ~ 1.25 मीटर/सेकेंड की निरंतर गति से ऑप्टिकली स्कैन किया जाता है। इस स्थिर गति को प्राप्त करने के लिए, ट्रैक के आंतरिक भाग पर स्कैन करते समय डिस्क का घुमाव ~8 रेव/सेकेंड से लेकर बाहरी भाग पर ~3.5 रेव/सेकेंड तक भिन्न होता है। गड्ढे और भूमि अवसाद (0.12 माइक्रोमीटर गहरे) और समतल खंड हैं जो ट्रैक के साथ बाइनरी डेटा बनाते हैं (0.6 माइक्रोमीटर चौड़ाई)।<ref>McEliece, Robert J. The Theory of Information and Coding: A Mathematical Framework for Communication. Reading, MA: Addison-Wesley Pub., Advanced Book Program, 1977. Print</ref>

सीडी प्रक्रिया को निम्नलिखित उप-प्रक्रियाओं के अनुक्रम के रूप में समझा जा सकता है:
* सिग्नल के स्रोत का चैनल एन्कोडिंग
* मास्टर डिस्क तैयार करने, उपयोगकर्ता डिस्क का उत्पादन करने और खेलते समय उपयोगकर्ता डिस्क पर एम्बेडेड संकेतों को अनुभूत करने की यांत्रिक उप-प्रक्रियाएँ - चैनल
* उपयोगकर्ता डिस्क से प्राप्त संकेतों को डिकोड करना

यह प्रक्रिया बर्स्ट त्रुटियों और यादृच्छिक त्रुटियों दोनों के अधीन है।<ref name="Algebraic Error Control Codes" /> बर्स्ट त्रुटियों में डिस्क सामग्री (एल्यूमीनियम प्रतिबिंबित फिल्म के दोष, पारदर्शी डिस्क सामग्री का व्यर्थ प्रतिबिंबित सूचकांक), डिस्क उत्पादन (डिस्क बनाने और डिस्क काटने आदि के समय दोष), डिस्क हैंडलिंग (स्क्रैच - सामान्यतः पतली, रेडियल और रिकॉर्डिंग की दिशा में ऑर्थोगोनल) और प्ले-बैक तंत्र में भिन्नताएं सम्मिलित हैं। यादृच्छिक त्रुटियों में पुनर्निर्मित सिग्नल तरंग की घबराहट और सिग्नल में हस्तक्षेप के कारण होने वाली त्रुटियां सम्मिलित हैं। सीआईआरसी (क्रॉस-इंटरलीव्ड रीड-सोलोमन कोडिंग|क्रॉस-इंटरलीव्ड रीड-सोलोमन कोड) सीडी प्रक्रिया में त्रुटि का पता लगाने और सुधार का आधार है। यह क्रमिक रूप से 3,500 बिट्स (सीडी सतह पर देखी गई लंबाई में 2.4 मिमी) तक त्रुटि बर्स्ट को ठीक करता है और 12,000 बिट्स (8.5 मिमी) तक त्रुटि बर्स्ट की भरपाई करता है जो सामान्य खरोंच के कारण हो सकते हैं।

एन्कोडिंग: ध्वनि-तरंगों का प्रतिरूप लिया जाता है और ए/डी कनवर्टर द्वारा डिजिटल रूप में परिवर्तित किया जाता है। ध्वनि तरंग का प्रतिरूप आयाम के लिए लिया जाता है (44.1 kHz या 44,100 जोड़े पर, स्टीरियो ध्वनि के बाएँ और दाएँ चैनलों के लिए एक-एक)। उदाहरण पर आयाम को लंबाई 16 की बाइनरी स्ट्रिंग सौंपी गई है। इस प्रकार, प्रत्येक प्रतिरूप दो बाइनरी सदिश <math>\mathbb{F}_2^{16}</math> या 4 <math>\mathbb{F}_2^{8}</math> डेटा के बाइट्स उत्पन्न करता है. रिकॉर्ड की गई ध्वनि के प्रत्येक सेकंड में 44,100 × 32 = 1,411,200 बिट्स (176,400 बाइट्स) डेटा प्राप्त होता है।<ref name="Lin, Shu" /> 1.41 एमबिट्स/एस प्रतिरूप डेटा स्ट्रीम त्रुटि सुधार प्रणाली से होकर निकलती है और अंततः 1.88 एमबिट्स/एस की स्ट्रीम में परिवर्तित हो जाती है।

एनकोडर के लिए इनपुट में 24 8-बिट प्रतीकों (ए/डी कनवर्टर से 12 16-बिट नमूने, बाएं और दाएं डेटा (ध्वनि) स्रोतों से 6 प्रत्येक) के इनपुट फ्रेम होते हैं। फ़्रेम <math>L_1 R_1 L_2 R_2 \ldots L_6 R_6</math> का प्रतिनिधित्व किया जा सकता है जहाँ <math> L_i </math> और <math>R_i</math> से बाएँ और दाएँ <math>i^{th}</math> फ़्रेम का प्रतिरूप चैनल से बाइट्स हैं .

प्रारंभ में, बाइट्स को नए फ़्रेम बनाने के लिए क्रमपरिवर्तित किया जाता है <math>L_1 L_3 L_5 R_1 R_3 R_5 L_2 L_4 L_6 R_2 R_4 R_6</math> जहाँ <math>L_i,R_i </math>प्रतिनिधित्व करना <math>i</math>-2 मध्यवर्ती फ़्रेमों के पश्चात फ़्रेम से बाएँ और दाएँ नमूने।

इसके पश्चात , इन 24 संदेश प्रतीकों को C2 (28,24,5) रीड-सोलोमन कोड का उपयोग करके एन्कोड किया गया है जो कि संक्षिप्त RS कोड <math>\mathbb{F}_{256}</math> है . यह दो-त्रुटि-सुधार करने वाला है, न्यूनतम दूरी 5 का है। यह अतिरेक के 4 बाइट्स जोड़ता है, <math>P_1 P_2</math> नया फ्रेम बनाना: <math>L_1 L_3 L_5 R_1 R_3 R_5 P_1 P_2 L_2 L_4 L_6 R_2 R_4 R_6</math>. परिणामी 28-प्रतीक कोडवर्ड को (28.4) क्रॉस इंटरलीवर के माध्यम से पारित किया जाता है, जिससे 28 इंटरलीव्ड प्रतीक बन जाते हैं। फिर इन्हें C1 (32,28,5) RS कोड से निकला जाता है, जिसके परिणामस्वरूप 32 कोडित आउटपुट प्रतीकों के कोडवर्ड प्राप्त होते हैं। किसी कोडवर्ड के विषम संख्या वाले प्रतीकों को अगले कोडवर्ड के सम संख्या वाले प्रतीकों के साथ फिर से समूहीकृत किया जाता है ताकि किसी भी छोटे बर्स्ट को तोड़ा जा सके जो उपरोक्त 4-फ्रेम विलंब इंटरलीविंग के पश्चात भी उपस्थित हो सकता है। इस प्रकार, प्रत्येक 24 इनपुट प्रतीकों के लिए 32 आउटपुट प्रतीक होंगे <math> R = 24/32 </math>. अंत में नियंत्रण और प्रदर्शन जानकारी की बाइट जोड़ी जाती है।<ref name="Lin, Shu" /> 33 बाइट्स में से प्रत्येक को ईएफएम (आठ से चौदह मॉड्यूलेशन) के माध्यम से 17 बिट्स में परिवर्तित किया जाता है और 3 मर्ज बिट्स को जोड़ा जाता है। इसलिए, छह नमूनों के फ्रेम का परिणाम 33 बाइट्स × 17 बिट्स (561 बिट्स) होता है, जिसमें 24 सिंक्रोनाइज़ेशन बिट्स और 3 मर्जिंग बिट्स जोड़े जाते हैं, जिससे कुल 588 बिट्स प्राप्त होते हैं।

डिकोडिंग: सीडी प्लेयर (सीआईआरसी डिकोडर) 32 आउटपुट सिंबल डेटा स्ट्रीम प्राप्त करता है। यह धारा पहले डिकोडर D1 से होकर निकलती है। डिकोडिंग विधियों पर निर्णय लेना और अपने उत्पाद प्रदर्शन को अनुकूलित करना सीडी प्रणाली के व्यक्तिगत डिजाइनरों पर निर्भर है। न्यूनतम दूरी 5 होने के कारण D1, D2 डिकोडर प्रत्येक के संयोजन को सही कर सकते हैं <math>e</math> त्रुटियाँ और <math>f</math> ऐसे मिटाता <math>2e+f<5</math> है .<ref name="Lin, Shu" /> अधिकांश डिकोडिंग समाधानों में, D1 को एकल त्रुटि को ठीक करने के लिए डिज़ाइन किया गया है। और 1 से अधिक त्रुटि के उपस्थितियां में, यह डिकोडर 28 इरेज़र आउटपुट करता है। अगले चरण में डीइंटरलीवर इन विलोपनों को 28 डी2 कोडवर्ड में वितरित करता है। पुनः अधिकांश समाधानों में, D2 को केवल मिटाने से निपटने के लिए सेट किया गया है ( सरल और कम महंगा समाधान)। यदि 4 से अधिक विलोपन का सामना करना पड़ता है, तो 24 विलोपन D2 द्वारा आउटपुट होते हैं। इसके पश्चात , त्रुटि छुपाने वाली प्रणाली अचूक प्रतीकों के उपस्थितियां में (पड़ोसी प्रतीकों से) प्रक्षेप करने का प्रयास करती है, जिसमें विफल रहने पर ऐसे गलत प्रतीकों के अनुरूप ध्वनियाँ म्यूट हो जाती हैं।

सीआईआरसी का प्रदर्शन:<ref name="Algebraic Error Control Codes" /> सीआईआरसी सरल रैखिक प्रक्षेप द्वारा लंबी बस्ट त्रुटियों को छुपाता है। 2.5 मिमी ट्रैक लंबाई (4000 बिट्स) अधिकतम पूरी तरह से सुधार योग्य बर्स्ट लंबाई है। 7.7 मिमी ट्रैक लंबाई (12,300 बिट्स) अधिकतम बर्स्ट लंबाई है जिसे इंटरपोल किया जा सकता है। बिट त्रुटि दर (बीईआर) पर प्रतिरूप प्रक्षेप दर हर 10 घंटे में होती है इस प्रकार <math>= 10^{-4}</math> और बीईआर पर प्रति मिनट 1000 नमूने = <math>10^{-3}</math> अज्ञात त्रुटि नमूने (क्लिक): बीईआर = पर प्रत्येक 750 घंटे में से कम <math>10^{-3}</math> और BER = पर नगण्य <math>10^{-4}</math> है

==यह भी देखें==
*[[त्रुटि का पता लगाना और सुधार करना]]
* प्रतिक्रिया के साथ त्रुटि-सुधार कोड
* [[कोड दर]]
* रीड-सोलोमन त्रुटि सुधार

==संदर्भ==
{{Reflist|33em}}
[[Category: कोडिंग सिद्धांत]] [[Category: त्रुटि का पता लगाना और सुधार करना]] [[Category: कंप्यूटर त्रुटियाँ]] 



[[Category: Machine Translated Page]]
[[Category:Created On 25/07/2023]]
[[Category:Vigyan Ready]]