קודים מתקני שגיאות Error Correcting Codes

1. קודים מתקני שגיאותError Correcting Codes

2. קודים מתקני שגיאותError Correcting Codes תזכורת: • קוד C הוא תת-קבוצה של כל המחרוזות{0,1,…,q-1}n • לכל קוד יש 4 מאפיינים עיקריים בהם נתעניין: • גודל האלפבית - q • מרחק – המספר המינימלי של תוים ששונים בין 2 מילות קוד, יחסית למספר התוים (n) • אורך הבלוק – כמות הביטים שאנחנו צריכים לכל מילת קוד, ז"א nlog(q) • קצב – כמות הביטים שהיינו צריכים לכל בלוק בקידוד אופטימאלי, ללא תיקון שגיאות, יחסית לאורך הבלוק (ז"א לוג מספר המילים בקוד) • דוגמא: • q = 3, n = 4 • C = {0121, 1210, 2101, 1012} • d[C] = d(1210, 1012) = 2/4 = 1/2 • r[C] = log(4) / 4log(3) = 1/(2log(3))

3. קודים מתקני שגיאותError Correcting Codes תזכורת: • קוד C הוא תת-קבוצה של כל המחרוזות{0,1,…,q-1}n • לכל קוד יש 4 מאפיינים עיקריים בהם נתעניין: • גודל האלפבית - q • מרחק – המספר המינימלי של תוים ששונים בין 2 מילות קוד, יחסית למספר התוים (n) • אורך הבלוק – כמות הביטים שאנחנו צריכים לכל מילת קוד, ז"א nlog(q) • קצב – כמות הביטים שהיינו צריכים לכל בלוק בקידוד אופטימאלי, ללא תיקון שגיאות, יחסית לאורך הבלוק (ז"א לוג מספר המילים בקוד) • מטרה: מרחק וקצב גדולים

4. קודים לינארייםLinear Codes • נניח שקיים שדה Fq בגודל q (לדוגמא F2 = {0,1}) • C הוא קוד לינארי אמ"ם הוא תת-מרחב של Fqn • ניתוח: • קצב – נסמן k=dim(C) • ב-C יש qk מילים • (C מורכב מצירופים לינאריים של: k איברי בסיס, q סקלרים לכל אחד) • r[C] = log(qk)/log(qn) = k/n • מרחק – d(x,y) = d(x-y,0) • לכן, מרחק הקוד יהיה המספר המינמלי של כניסות שונות מ-0 • דוגמא: • q = 2, n = 5 • C = span{10101, 11100} • k = 2, r[C] = 2/5 • d[C] = d(01001,00000) = 2/5

5. איך מקודדים איברים ב-Fq? Reed-Solomon Code • פולינומיםמדרגה k-1 מעל שדה (סופי) Fq: f(x) = ∑aixi • מילות הקוד – הערכים של הפולינום בכל הנקודות ב-Fq • מאפיינים: • מימד - k • קצב – k/q • מרחק - (q-k+1)/q • דוגמא: • q=3, k=2 • {0, 1, 2, x, x+1, x+2, 2x, 2x+1, 2x+2} • C = {(0,0,0), (1,1,1), (2,2,2), (0,1,2), (1,2,0), (2,0,1), (0,2,1), (1,0,2), (2,1,0)}

6. Hadamard Code פונקציות לינאריות F2n->F2: fS(x) = ∑i∈S xi מילות הקוד – הערכים של fS על כל אחד מ-2n הקלטים האפשריים ל-fS. מאפיינים: קצב – n/2n מרחק - 1/2 • דוגמא: • n=2 • {0, x0, x1, x0 + x1} • C = {(0,0,0,0), (0,1,0,1), • (0,0,1,1), (0,1,1,0)}  רע מאד כש-n גדול...

7. Hadamard Code פונקציות לינאריות F2n->F2: fS(x) = ∑i∈S xi מרחק - ½: נניח בה"כ ש- 0∈S נחלק את כל הוקטורים לזוגות: x0→0=(0, x1, … xn) , x1→0=(1, x1, … xn) fS(x1→0) = 1 + ∑i∈S\{0} xi = 1 + fS(x0→0) fS מתאפסת רק על וקטור אחד מכל זוג סה"כ – fS מתאפסת על חצי מהקלטים האפשריים מסקנה:d[CH] = 1/2

8. שרשור קודיםCode Concatenation • לקוד RS יש קצב טוב, אבל הוא לא בינארי • קוד הדמר הוא בינארי, אבל יש לו קצב גרוע • איך אפשר לשלב? • נקודד את אברי השדה Fq בעזרת הדמר ונשתמש באיברים המקודדים לקוד RS. • מאפיינים: • קצב – log(qk) / q*q = k*log(q) / q2 • מרחק – (q-k+1)/2q

9. שרשור קודיםCode Concatenation • נקודד את אברי השדה Fq בעזרת הדמר ונשתמש באיברים המקודדים לקוד RS • קצב – k*log(q) / q2מרחק – (q-k+1)/2q • דוגמא: k = 2, q = 3⇐ n = 2 • CH = {(0,0,0,0), (0,1,0,1), (0,0,1,1), (0,1,1,0)} • CRS = {(0,0,0), (1,1,1), (2,2,2), (0,1,2), (1,2,0), (2,0,1), (0,2,1), (1,0,2), (2,1,0)} • CRS◦H = {0000-0000-0000, 0101-0101-0101, 0011-0011-0011, 0000-0101-0011, …} “0” “1” “2”

10. קוד ליניארי אקראי • לכל מטריצה nXk מתאים הקוד הנוצר (generated) ע"י המטריצה: • CG = {G∙x : x ∈ Fqk} ⊆ Fqn • dim(CG) = rank(G) ≤ k • r[CG] = dim(CG) / n ≤ k/n • d[CG] = …? • טענה: קוד שנוצר ע"י מטריצה אקראית הוא "טוב"בהסתברות "גבוהה": • מרחק קבוע • קצב קבוע מתי מתקיים שוויון?

11. קוד ליניארי אקראי • טענה: קוד שנוצר ע"י מטריצה אקראית הוא "טוב"בהסתברות "גבוהה". • CG = {G∙x : x ∈ {0,1}k} • הוכחה - מרחק: • לכל 0≠x ∈ {0,1}k , נסמן y = G∙x ∈ {0,1}n, ואז: • Pr[ dist(y,0) < α ] = Pr[ ∑(1-yi) > (1-α)∙n ] • = Pr[ ∑(1-yi ) > 2(1-α)∙E[∑(1-yi)] ] • < 2-c(α)∙E[∑(1-yi)] • = 2-c(α)∙n/2

12. קוד ליניארי אקראי • טענה: קוד שנוצר ע"י מטריצה אקראית הוא "טוב"בהסתברות "גבוהה". • CG = {G∙x : x ∈ {0,1}k} • הוכחה - מרחק: • לכל 0≠x ∈ {0,1}k , • Pr[ dist(G∙x,0) < α ] < 2-c(α)∙n/2 • חסם איחוד על כל ה-x-ים ב-{0,1}k: • Pr[ d[CG] < α ] < 2k∙Pr[ dist(G∙x,0) < α ] • < 2k-c(α)∙n/2 • ⇐ למשל, נקח k = c(α)∙n/4 כדי לקבל מרחק לפחות αבהסתברות כמעט 1.

13. קוד ליניארי אקראי טענה: קוד שנוצר ע"י מטריצה אקראית הוא "טוב"בהסתברות "גבוהה". CG = {G∙x : x ∈ {0,1}k} הוכחה – קצב: מתי נקבל r[CG] = k/n? כאשר וקטורי העמודה של G הם בת"ל ב-{0,1}n ... אבל אם הם תלויים לינארית אז קיים x כך ש- G∙x = 0 (ז"א שלקוד יש "מרחק 0")