‫בס"ד‬

‫תרגול כתה ‪12‬‬

‫קוד ברגר‪:‬‬
‫אורך ‪n‬‬
‫מספר ביטי אינפורמציה ‪k :‬‬
‫מספר ביטי יתירות ‪r = log 2 ( k + 1)  :‬‬
‫מתקיים‪n=k+r :‬‬
‫זהו קוד לגילוי שגיאה בודדת חד כיוונית ‪) .Unidirectional‬יתירות מינימלית עבור מטרה זו(‬
‫אופן הקידוד‪:‬‬
‫שתי סכמות‪:‬‬
‫סכמה ראשונה ‪:B1‬סופרים את מספר האחדות בחלק של האינפורמציה‪ .‬כותבים את הערך הבינארי‪,‬‬
‫היתירות תהיה הערך המשלים עבור כל ביט‪.‬‬
‫דוגמא מספר ‪:1‬‬
‫מהו קידוד ברגר של מילת האינפורמציה הבאה‪:‬‬
‫‪0100101‬‬
‫‪r = log 2 ( 7 + 1)  = 3‬‬
‫ביטי יתירות )מפני שעבור ‪ 7‬ביטים‪,‬‬
‫יש ‪ 7‬ביטי אינפורמציה לכן צריך‬
‫יכולים להיות בין ‪ 0‬ל‪ 7-‬אחדות‪ ,‬כלומר ‪ 8‬אפשרויות שונות(‬
‫יש שלוש אחדות באינפורמציה‪ -‬בבינארית זה ‪ 011‬והמשלים של זה הוא ‪100‬‬
‫בסה"כ הקוד הוא ‪0100101-100‬‬
‫סכמה שניה‪B0:‬‬
‫סופרים את מספר האפסים‪ ,‬כותבים את הערך הבינארי בתור היתירות‪.‬‬
‫דוגמא‪:‬‬
‫מהו קידוד ברגר של מילת האינפורמציה הבאה‪:‬‬
‫‪0100101‬‬
‫יש ‪ 4‬אפסים‪ ,‬בבינארית זה ‪.100‬‬
‫בסה"כ הקוד הוא ‪0100101-100‬‬
‫קוד סמית‪:‬‬
‫אפשר להשתמש בקוד סמית כאשר חלק מתת הקבוצות של מילות הקוד המקורי הן ‪) unordered‬לא‬
‫מכסות אחת את השניה( וחלק מתת הקבוצות הן ‪.ordered‬‬
‫המטרה‪ :‬לאחר קידוד סמית‪ ,‬טעות בסיבית בודדת לא תעביר אותנו למילת קוד חוקית‪.‬‬
‫לאחר קידוד סמית אף מילת קוד לא מכסה את השניה‪.‬‬
‫דוגמא ניקח את מילות האינפורמציה }‪) {000},{011},{110},{111‬שימו לב‪ ,‬לא כל ‪ 8‬האפשרויות‬
‫עבור ‪ 3‬ביטים הן מילות אינפורמציה חוקיות במקרה זה ‪ ,‬עבור החלק של האינפורמציה‪ ,‬לפני‬
‫הקידוד(‬
‫‪ 1.‬מסדרים את אוסף מילות הכניסה לפי דיאגרמת הסה‪:‬‬

‫‪111‬‬

‫‪011‬‬

‫‪110‬‬

‫‪000‬‬
‫בדוגמא הפשוטה הזו יש ‪ 2‬שרשראות של כיסוי בדיגרמת הסה‪:‬‬

‫}‪{000},{110},{111‬‬
‫}‪{000},{011},{111‬‬
‫כל שרשרת ניתן לקודד באופן בלתי תלוי באחרות‪.‬‬
‫לכן ניתן לקודד כל רמה בדיאגרמת הסה באופן הבא‪:‬‬

‫‪00‬‬

‫‪111‬‬

‫‪011‬‬

‫‪110‬‬

‫‪000‬‬

‫‪01‬‬

‫‪10‬‬

‫קוד סמית המתקבל הוא ‪:‬‬

‫‪Smith Redandency‬‬
‫‪s1‬‬
‫‪s2‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬

‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬

‫‪information bits‬‬
‫‪x2‬‬
‫‪x3‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬

‫‪x1‬‬

‫שימו לב שהקוד המתקבל הוא אכן ‪.unordered‬‬
‫הערות‪:‬‬
‫את היתירות ניתן לקודד כרצוננו בתנאי שתפרק את השרשרת‪.‬‬
‫צריך לוודא שלא נוצרה שרשרת חדשה‪.‬‬
‫גודל הזנב מושפע מכמות המילים בשרשרת הכי ארוכה‪.‬‬

‫שימו לב‪ ,‬קוד סמית מושפע מאורך השרשרת ‪ ,‬לעומת קוד ברגר שמושפע מאורך המילה‪.‬‬
‫לכן כדאי להשתמש בקוד סמית כאשר יש שרשראות קצרות‪.‬‬

‫מועד א' ‪:2010‬‬

‫‪y1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬

‫‪y2‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬

‫‪y3‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬

‫‪y4‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬

‫‪y5‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬

‫‪digit‬‬
‫‪0‬‬
‫‪1‬‬
‫‪2‬‬
‫‪3‬‬
‫‪4‬‬
‫‪5‬‬
‫‪6‬‬
‫‪7‬‬
‫‪8‬‬
‫‪9‬‬

‫יש לנו ‪ 5‬ביטי אינפורמציה לכן נצטרך ‪ r = log 2 (5 + 1)  = 3‬ביטי יתירות עבור קוד ברגר‬
‫לא רשום אם להשתמש ב‪ B0‬או ב‪ B1‬לכן אנחנו יכולים לבחור להשתמש ב‪ B1‬למשל‪.‬‬

‫‪b1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬

‫‪b2‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬

‫‪b3‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬

‫‪y1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬

‫‪y2‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬

‫‪y3‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬

‫‪y4‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬

‫‪y5‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬

‫הערה ‪ :‬אנחנו יודעים שקוד ברגר הוא בעל היתירות המינימלית עבור גילוי שגיאה חד כיוונית בודדת‪,‬‬
‫אבל כלל זה הוא לגבי מקרים שבהם כל האפשרויות של מילות האינפורמציה הם חוקיות‪ ,‬וזה לא‬
‫המקרה‪ ,‬אז האופציה קיימת‪ .‬אם כל המסלולים בדיאגרמת הסה יהיו באורך של לכל היותר ‪ 4‬נוכל‬
‫לחסוך עם קוד סמית‪.‬‬
‫נצייר את דיאגרמת הסה‪:‬‬
‫נראה שהמסלול המקסימלי הוא באורך ‪ 3‬לכן באמצעות קוד סמית ניתן להוריד סיבית אחת‬
‫מהיתירות‪.‬‬
‫מעגלים‪:‬‬
‫‪:Dual Rail Checker‬‬
‫ל‪ checker‬יש שתי קבוצות של אינפוטים‪ (x1, …, xn) :‬ו‪ (y1, …, yn) -‬ושני מוצאים ‪.f, g :‬‬
‫‪ f ,g‬יהיו בעלי ערכים משלימים )מנוגדים( )כלומר ‪ 1‬מתוך ‪ (2‬אם ורק אם לכל ‪ j‬מתקיים שגם ‪xj, yj‬‬
‫משלימים‪.‬‬

‫‪x0‬‬

‫‪y0‬‬

‫‪x1‬‬

‫‪yn-1 xn-1‬‬

‫‪y1‬‬

‫‪Totally self-checking two-rail checker‬‬

‫‪1-out-of-2‬‬

‫‪digit‬‬
‫‪0‬‬
‫‪1‬‬
‫‪2‬‬
‫‪3‬‬
‫‪4‬‬
‫‪5‬‬
‫‪6‬‬
‫‪7‬‬
‫‪8‬‬
‫‪9‬‬

:n=2 ‫המעגל עבור‬

f = x0 y1 + y0 x1
g = x0 x1 + y0 y1
x1

y1

x0

y0

f

g

0

0

0

0

0

0

x0

0

0

0

1

0

0

y0

0

0

1

0

0

0

f

x1

0

0

1

1

0

0

g
y1

0

1

0

0

0

0

0

1

0

1

0

1

0

1

1

0

1

0

0

1

1

1

1

1

1

0

0

0

0

0

1

0

0

1

0

1

1

0

1

0

1

0

1

0

1

1

1

1

1

1

0

0

0

0

1

1

0

1

1

1

1

1

1

0

1

1

1

1

1

1

1

1

‫ניתן לשרשר את הרכיב עבור ‪ n=2‬כדי לקבל בודק עבור ערכי ‪ n‬כלשהם‪:‬‬

‫‪y4‬‬

‫‪x3‬‬

‫‪y3 x4‬‬

‫‪x2 y2‬‬

‫*‬
‫‪g2‬‬
‫‪y6‬‬

‫‪y5 x6‬‬

‫*‬
‫‪g1‬‬

‫‪f2‬‬

‫‪f1‬‬

‫‪x5‬‬

‫*‬
‫‪g4‬‬

‫‪y1‬‬

‫‪x1‬‬

‫*‬
‫‪g3‬‬

‫‪f4‬‬

‫‪f3‬‬

‫*‬
‫‪g‬‬

‫‪f‬‬

‫בניית בודק לקוד ברגר מבוסס ‪: Dual Rail‬‬
‫נשתמש ב‪:B1‬‬
‫הרעיון הכללי‪:‬‬
‫נסכום את כמות האחדות של ביטי האינפורמציה‪ ,‬ואת התוצר נכניס ל‪ dual rail‬מול ביטי היתירות‪.‬‬
‫נחזור לדוגמא מספר ‪:1‬‬

x1
x2
x3

C

C

S

FA
S

FA

g3

f

g2

x4
x5
x6
x7

H3
H2
H1

g1
C
FA
S

C
FA
S

g

‫נבחר לבנות בודק מבוסס ‪) dual rail‬יש עוד בודק שנכיר בהמשך(‬

‫ניקח לדוגמא את המילה ‪.11110011‬‬
‫‪ 5‬ביטי האינפורמציה צריכים להכנס‪ ,‬לפי הסדר הנכון לכניסות המחברים‪ ,‬ושלושת ביטי היתירות‬
‫צריכים להכנס לפי הסדר הנכון ל‪ .H‬אם ערכי ‪ f,g‬מנוגדים אזי המילה תקינה )לכן כאשר מכניסים‬
‫מילה תקינה ערכי המוצא צריכים להיות מנוגדים(‪ .‬נראה זאת על גבי הציור של הבודק‪.‬‬

‫נניח על הקווים הייתה אותה המילה מהסעיף הקודם וחלה שגיאה אסימטרית ‪ ,‬בכיוון מעלה‪ ,‬בביט‬
‫‪ ,y1‬כלומר עכשיו המילה על הקווים בכניסה היא ‪ .11111011‬נדגים זאת על גבי הציור של הבודק‪.‬‬

‫‪ self-dual-complement‬עבור קוד ברגר‪:‬‬
‫נתונה הפונקציה )‪f ( x‬‬
‫בוחרים פונקציה כלשהי )‪ h( x‬הידועה כ‪SD‬‬

‫מחפשים פונקציה )‪ SD complement' - δ ( x‬ע"י )‪δ ( x) = h( x) ⊕ f ( x‬‬
‫אזי מתקיים גם )‪h( x) = f ( x) ⊕ δ ( x‬‬
‫למעגל נוסיף יציאה )‪ , δ ( x‬אשר ממנה ומ )‪ f ( x‬תחושב )‪h( x) = f ( x) ⊕ δ ( x‬‬

‫בזמן ‪ t‬נכניס )‪ f ( x‬ונקבל )‪h( x‬‬
‫בזמן ‪ t+1‬נכניס )‪ f ( x‬ונקבל )‪ h( x‬מפני ש )‪ h( x‬היא ‪SD‬‬
‫אם מתקבל ])‪ [ h( x), h( x‬כלומר ‪ 01‬או ‪ 10‬אזי לא חלה שגיאה‪ .‬אחרת‪ ,‬חלה שגיאה‪.‬‬

‫דוגמא‪ -‬נתונה הפונקציה‬
‫נבחר פונקציה ‪ SD‬כרצוננו ‪ ,‬עם אותה כמות משתנים‪ ,‬למשל‬

‫היא ‪ SD‬מפני ש‬

‫) ‪h( x1 , x2 , x3 ) = ( x1 + x2 )( x2 + x3 )( x1 + x3 ) = ( x1 x2 + x1 x3 + x2 + x2 x3 )( x1 + x3‬‬
‫‪= x1 x2 + x1 x2 x3 + x1 x3 + x1 x3 + x2 x1 + x2 x3 + x1 x2 x3 + x2 x3 = x1 x2 + x2 x3 + x1 x3‬‬
‫נמצא את )‪: δ ( x‬‬

‫) ‪δ ( x) = ( x1 x2 + x2 x3 + x1 x3 ) ⊕ ( x1 + x2 x3‬‬
‫נצמצם על ידי קוביות ונקבל‪:‬‬

‫מועד א'‪:2011 -‬‬

‫את הטבלה אפשר למלא על ידי מעקב אחרי המעגל או על ידי כתיבת המשוואות של המוצאים‪:‬‬
‫‪f3‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬

‫‪f2‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬

‫‪f1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬

‫‪d‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬

‫‪c‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬

‫‪b‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬

‫‪a‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬

‫‪f1 = bd + ab‬‬
‫‪f 2 = ab + c + bcd = ab + c‬‬
‫‪f 3 = a + bcd‬‬
‫לכן אוסף המילים היכולות להופיע במוצא המערכת הוא }‪{000, 010,100,111, 001, 011‬‬
‫המילים שאינן בקוד הן }‪{101,110‬‬

‫ניקח ‪ a = 0, b = 0, c = 1, d = 0‬למשל‪.‬‬
‫אם קרתה התקלה המתוארת‪ f 2 ,‬ייתן ‪ 0‬במקום ‪.1‬‬

‫הגדרה‪ :‬מערכת היא ‪ fault secure‬אם כאשר חלה שגיאה בהכרח המוצא יחזיר מילה לא חוקית או‬
‫את המילה הנכונה‪) .‬לא ימופה למילה חוקית אחרת(‬

‫המערכת הזו אינה ‪ ,fault secure‬למשל אם המילה מקורית הייתה ‪ a = 1, b = 0, c = 0, d = 0‬ושער‬
‫‪ 8‬נתקע על ‪ 0‬אזי נקבל במוצא ‪ 000‬במקום ‪001‬‬

‫הגדרה‪:‬‬
‫המערכת היא ‪ self-testing‬אם לכל שגיאה קיימת לכל הפחות כניסה אחת שתתגלה אותה ותחזיר‬
‫מילה שאינה מילת קוד‬
‫הגדרה‪ -totally self checking :‬מקיים את שתי הדרישות )כלומר או שהשגיאה תזוהה או שלא‬
‫תגרום נזק(‬
‫המערכת אינה ‪:self-testing‬‬
‫אם חלה שגיאה של ‪ stuck at 1‬בשער ‪6‬אזי ערכי המוצאים ‪ f2,f3‬יהיו תמיד ‪ 1‬לכן תמיד תתקבל או‬
‫המילה ‪ 111‬או המילה ‪ 011‬ששתיהן חוקיות‪.‬‬