‫בס"ד‬

‫תרגול כתה ‪11‬‬
‫פונקציות ‪:Majority‬‬
‫פונקציית רוב עבור ‪ 3‬משתנים‪:‬‬

‫מימוש פונקציות באמצעות פונקציית רוב‪:‬‬

‫משפט‪:‬‬
‫ניתן לממש כל פונקציה של שלושה משתנים באמצעות שתי רמות של פונקציות רוב בתוספת‬
‫מהפכים על הכניסות של הרמה הראשונה‪.‬‬

‫מימוש באמצעות פונקציות רוב של ‪ 3‬משתנים‪:‬‬
‫דוגמאות‪:‬‬

:‫מועד א' תשס"ט‬

:‫פתרון אפשרי‬

xy = x # y #0
yw = y # w # 0
zx = z # x #0
zw = z # w # 0

x y + yw + z x + zw = ( x # y # 0) + ( y # w #0) + ( z # x #0) + ( z # w #0)
= [( x # y #0) + ( y # w #0)] + [( z # x #0) + ( z # w #0)] =
[( x # y # 0) #( y # w #0) #1] + [( z # x #0) #( z # w #0) #1] =
[( x # y # 0) #( y # w #0) #1]#[( z # x #0) #( z # w # 0) #1] =

:‫שיטות נוספות‬

:‫רדוקציה של הדומיין‬
:‫נתונה הפונקציה‬

x1,x2
"00"
"01"
"11"
"10"

x3,x4,x5
"000"
0
0
0
0

x1,x2
"00"
"01"
"11"
"10"

x3,x4,x5
"000"
0
0
0
0

"001"

"011"
0
1
0
0

"001"

"010"
0
1
1
0

"011"
0
1
1
0

"110"
0
0
0
0

"010"
0
1
1
0

"111"
1
1
1
0

"110"
0
0
1
0

"101"
1
1
1
1

"111"
0
1
1
0

"100"
1
1
1
1

"101"
0
1
1
1

0
0
1
0

"100"
0
1
1
1

0
1
1
0

Y1 = x1 # x2 # x5
x1,x2
"00"
"01"
"11"
"10"

x3,x4,x5
"000"
0
0
0
0

"001"

"011"
0
1
1
0

"010"
0
1
1
0

"110"
0
0
1
0

"111"
0
1
1
0

"101"
0
1
1
1

"100"
0
1
1
1

0
1
1
0

Y2 = x1 # x2 # x3
x1,x2
"00"
"01"
"11"
"10"

x3,x4,x5
"000"
0
0
0
0

"001"

"011"
0
1
1
0

"010"
0
1
1
0

"110"
0
0
1
0

"111"
0
1
1
0

"101"
0
1
1
1

"100"
0
1
1
1

0
1
1
0

Y3 = x3 # x4 # x5
F = Y1 # Y2 # Y3

‫רדוקציה על סט המשתנים‪:‬‬
‫ראינו איך ניתן לממש כל פונקציה של ‪ 3‬משתנים באמצעות פונקצית סף‪ .‬נשתמש בבניה הבאה כדי‬
‫לממש כל פונקציה ב‪ n-‬משתנים‪:‬‬

‫)‪f1(x ,W‬‬
‫‪#‬‬

‫)‪f2(y ,W‬‬
‫)‪f3(z ,W‬‬
‫)‪f4(x ,W‬‬

‫)‪F(x ,y ,z ,W‬‬

‫‪#‬‬

‫‪#‬‬

‫)‪f5(y ,W‬‬
‫)‪f6(z ,W‬‬
‫)‪f7(x ,W‬‬

‫‪#‬‬
‫‪.‬‬

‫נתונה הפונקציה הבאה‪:‬‬

‫הדקומפוזיציה היא‪:‬‬

‫)‪f8(y ,W‬‬
‫)‪f9(z ,W‬‬

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

‫דוגמא נוספת לרדוקציה על המשתנים‪:‬‬
‫נתונה הפונקציה‪:‬‬

‫פתרון‪:‬‬
‫שימו לב‪ ,‬התנהגות הפונקציה ‪:f‬‬
‫‪ f=1‬כאשר מתקיימת אחת מהאפשרויות הבאות‪:‬‬

‫)‪F2 (Y‬‬
‫‪X‬‬
‫‪1‬‬
‫‪1‬‬

‫‪xi‬‬
‫‪1‬‬
‫‪1‬‬
‫‪X‬‬

‫)‪F1(Y‬‬
‫‪1‬‬
‫‪X‬‬
‫‪1‬‬

‫‪ f=0‬כאשר מתקיימת אחת מהאפשרויות הבאות‪:‬‬
‫)‪F2 (Y‬‬
‫‪X‬‬
‫‪0‬‬
‫‪0‬‬

‫‪xi‬‬
‫‪0‬‬
‫‪0‬‬
‫‪X‬‬

‫)‪F1(Y‬‬
‫‪0‬‬
‫‪X‬‬
‫‪0‬‬

‫עבור המקרה הראשון‪ f1=1 ,‬ולכן או ש‪ f1Q=1‬או ש‪ .f1Q'=1‬לכן או ‪ A‬או ‪ B‬ייתנו ‪ 1‬והפונקציה‬
‫החדשה תחזיר ‪.1‬‬
‫עבור המקרה השני‪ f2=1 ,‬ולכן או ש‪ f2Q=1‬או ש‪ .f2Q'=1‬לכן או ‪ A‬או ‪ B‬ייתנו ‪ 1‬והפונקציה החדשה‬
‫תחזיר ‪.1‬‬
‫עבור המקרה השלישי‪ f1=1,‬וגם ‪ f2=1‬לכן‬

‫‪A = Q +Q' =1‬‬
‫‪B = Q +Q' =1‬‬

‫והפונקציה החדשה תחזיר ‪.1‬‬

‫באופן דומה ניתן להראות עבור המקרים שהמוצא הוא ‪.0‬‬
‫בהוכחה לא השתמשנו בכלל בהנחות על ! והוא יכול להיות כל פונקציה‪.‬‬

‫גילוי שגיאות במעגל‪:‬‬

‫סוגי שגיאות במעגל‪:‬‬

‫קוד ברגר‪:‬‬
‫אורך ‪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‬‬

‫‪10‬‬

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

‫‪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‬‬

‫‪01‬‬

‫‪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‬‬

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

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

‫המקרה‪ ,‬אז האופציה קיימת‪ .‬אם כל המסלולים בדיאגרמת הסה יהיו באורך של לכל היותר ‪ 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‬‬

: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

g1
C
FA
S

C
FA
S

x7

H3
H2
H1

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

g