נפה ריבועית

שיטת הנפה הריבועית היא שיטה מהירה לפירוק לגורמים של מספר שלם, המתאימה בעיקר למספרים בני 40–100 ספרות עשרוניות (אלגוריתם rho של פולרד עדיף לפירוק מספרים קטנים יותר, בעוד שבמספרים ארוכים יותר נפת שדה המספרים היא השיטה היעילה ביותר).

שיטת הנפה הריבועית, שהייתה השיטה הראשונה בעלת סיבוכיות תת-מעריכית לבעיית הפירוק לגורמים, פותחה על ידי קארל פומרנץ בשנת 1981. פומרנץ הרחיב, למעשה, רעיונות קודמים של וג'ון ד' דיקסון. זו הייתה השיטה המהירה ביותר (באופן אסימפטוטי), עד להמצאתה של נפת שדה המספרים, ב-1993.

==עקרונות הנפה הריבועית==
בדומה לשיטות פירוק אחרות של מספרים שלמים הנקראות "ריבוע אקראי" (Random square), גם שיטת הנפה הריבועית מנסה לאתר זוג שלמים אקראיים <math>x,y</math> עבורם <math>x^2\equiv y^2\!\!\!\pmod{n}</math> אבל <math>x\not\equiv y\!\!\!\pmod{n}</math>. זוג כזה מאפשר לפרק את <math>n</math>, משום ש-<math>n\mid(x^2-y^2)=(x-y)(x+y)</math> אולם אינו מחלק של <math>x-y</math> או <math>x+y</math>. על כן בסבירות גבוהה המחלק המשותף המקסימלי <math>\gcd\{x-y,n\}</math> (שאותו אפשר למצוא ביעילות באמצעות אלגוריתם אוקלידס) יהיה גורם אמיתי של <math>n</math>.

בקווים כלליים, הנפה הריבועית מבוססת על ייצור מספרים שיש להם הצגה ידועה כמספר ריבועי מחד, והצגת מספרים השקולים למכפלות של מספרים כאלה מודולו <math>n</math> כריבועים בעזרת פירוק חלקי לגורמים, מאידך.

נגדיר <math>Q(x)=(x+\lfloor\sqrt{n}\rfloor)^2-n=\overset{\sim}{x}^2-n</math>, ונחשב את <math>Q(x_1),Q(x_2),\ldots,Q(x_k)</math> (בסעיפים הבאים יוסבר כיצד למצוא <math>x_i</math> מתאימים).

מתוך קבוצת ה-<math>Q(x)</math> אנחנו מחפשים תת-קבוצה של מספרים, שמכפלתם היא ריבוע ידוע: <math>Q(x_{i_1})Q(x_{i_2})\cdots Q(x_{i_r})=y^2</math>. ברגע שמטרה זו הושגה מתקיים <math>Q(x)\equiv\overset{\sim}{x}^2\!\!\!\pmod{n}</math>, ולכן גם
:<math>Q(x_{i_1})Q(x_{i_2})\cdots Q(x_{i_r})\equiv(\overset{\sim}{x}_{i_1}\cdot\overset{\sim}{x}_{i_2}\cdots\overset{\sim}{x}_{i_r})^2\!\!\!\pmod{n}</math>
כך מצאנו <math>x,y</math> מתאימים לדרישות. אם המספר <math>n</math> הוא מכפלה של שני מספרים ראשוניים גדולים, אז מתקיים בהסתברות <math>x\equiv\pm y\!\!\!\pmod{n}</math> בהסתברות 0.5, ואז תוצאת ה-gcd תהיה <math>n</math> או 1; במקרה כזה יש להמשיך את תהליך הייצור, ולמצוא זוג אחר של מספרים כמתואר לעיל.

==תיאור האלגוריתם==
קלט: מספר פריק <math>n</math>

פלט: אחד הגורמים הראשוניים של <math>n</math>

#בחירת גורמי בסיס
#:בוחרים בסיס גורמים (Factor base) אותו מסמנים <math>S=p_1,p_2,\ldots,p_t</math>, כאשר <math>p_1=-1</math> ויתר האלמנטים הם המספרים הראשוניים <math>p_i</math> החל מ-2 ועד לגבול מסוים, כאשר בוחרים רק את הראשוניים <math>p_i</math> אשר <math>n</math> הוא שארית ריבועית מודולו <math>p_i</math>, כלומר שלהם סימן לז'נדר <math>\left(\frac{n}{p}\right)=1</math>. הגבול העליון <math>B</math> נקרא גבול חלקות (Smoothness bound) ולמעשה מכתיב את גודל בסיס הגורמים. הערך <math>t</math> מייצג את מספר הגורמים הראשוניים בבסיס, מספר זה ישפיע ישירות על כמות הווקטורים הדרושים לפירוק <math>n</math> ועל גודלם.
#הכנת מאגר זוגות שלמים <math>a_i,b_i</math>
#:מכינים <math>t+1</math> זוגות שלמים <math>a_i,b_i</math> כדלהלן: מחשבים את השורש השלם של <math>n</math> אותו מסמנים ב-<math>m</math>. מכינים את הפולינום <math>q(x)=(x+m)^2-n</math>, מחשבים את <math>b_i=q(x)</math> ובודקים אם <math>b_i</math> הוא מספר חלק ביחס ל-<math>B</math> (כלומר שכל גורמיו הראשוניים נמצאים בבסיס הגורמים). אם <math>b_i</math> אינו מספר חלק ביחס ל-<math>B</math>, בוחרים <math>x</math> אחר (לפי הסדר הזה: <math>0,-1,+1,-2,+2,\ldots</math>). אם <math>b_i</math> הוא אכן מספר חלק כלומר ניתן לייצגו כמכפלה של גורמי בסיס: <math>b_i=\prod_{j\,=\,1}^tp^{e_{ij}}_j</math>, אזי מגדירים את <math>a_i=x+m</math>, זוג הערכים <math>(a_i,b_i)</math> נוסף למאגר. הערה: ניתן לבדוק חלקות באמצעות חלוקה נסיונית (פשוט על ידי חלוקה בכל גורמי הבסיס), אולם שלב זה הוא הקריטי והארוך ביותר באלגוריתם ועל כן יעילותו מתבטאת בעיקר באופן בו מיושמת בדיקת החלקות. באופן מעשי מקובל להשתמש בתהליך הניפוי (sieving) המתואר להלן.
#מציאת מספר ריבועי
#:כיוון שהגורמים של כל <math>b_i</math> ידועים, קל למצוא תת-קבוצה של <math>b_i</math> אשר מכפלתה היא מספר ריבועי. כיוון שצריך רק מספרים שהחזקה של כל גורם <math>p_i</math> שלהם זוגית. ניתן לפשט זאת על ידי הכנת וקטור בינארי של המעריכים מודולו 2 כלומר <math>(v_{i1},v_{i2},\ldots,v_{it})</math> כאשר <math>v_{ij}=e_{ij}\bmod2</math>. כיוון שבהכרח בוקטור זה תמצא תלות ליניארית כלשהי, משתמשים באלגברה ליניארית כדי למצוא תת-קבוצה <math>T</math> של וקטורים שסכומה הוא וקטור האפס <math>\sum_{i\,\in\,T}v_i=0</math>. משנמצאה תת-קבוצה כזו, מכפילים את המספרים החלקים <math>b_i</math> המתאימים (שהמציין <math>i</math> שלהם ב-<math>T</math>), כלומר מחשבים את <math>x=\prod_{i\,\in\,T}a_i\bmod n</math>. בהכרח מתקיים כי <math>\prod_{i\,\in\,T}b_i</math> הוא מספר ריבועי. כמו כן ניתן לראות שגם מכפלת ריבועיהם של כל <math>a_i</math> המתאימים יהיה מספר ריבועי. כלומר <math>\prod_{i\,\in\,T}a^2_i\bmod n</math> נותן מספר ריבועי.
#חישוב <math>x,y</math>
#:מחשבים את השורשים הריבועיים של התוצאה האמורה, את האחד מוצאים על ידי חישוב שורש ריבועי של התוצאה האמורה ואת השני על ידי הכפלת מספרי <math>a_i</math> המתאימים. מציבים ב-<math>x</math> את <math>\prod_{i\,\in\,T}a_i</math> וב-<math>y</math> את השורש הריבועי של <math>\prod_{i\,\in\,T}b_i</math>. מספרים אלה עונים על הדרישה האמורה, כלומר ריבועיהם שקולים מודולו <math>n</math>. בדרך כלל קיימות מספר תלויות ליניאריות כך שבסבירות גבוהה אחת מהן תניב <math>x,y</math> כאלה שאינם שקולים מודולו <math>n</math>.
#מציאת גורם ראשוני
#:מחשבים את המחלק המשותף המקסימלי של ההפרש של <math>x-y</math> עם <math>n</math>. התוצאה תהיה גורם ראשוני של <math>n</math>, אשר עשוי להיות גם גורם טריוויאלי כמו <math>n</math> עצמו או 1. במקרה כזה, מנסים שוב עם תלות ליניארית אחרת של המספרים החלקים.

==הגדרת בסיס הגורמים וטווח הניפוי==
שיטת הנפה דורשת דרך יעילה למצוא <math>x_i</math> כך שהמכפלה <math>\prod Q(x_i)</math> תתן מספר ריבועי. כדי שזה יתקיים צריך שכל גורם ראשוני המחלק את המכפלה יחלק אותה מספר זוגי של פעמים. לשם כך צריך לפרק לגורמים ראשוניים כל אחד מן המספרים <math>Q(x_i)</math> המרכיבים את המכפלה.

כדי לפשט את הבדיקה אנחנו מעוניינים כי <math>Q(x_i)</math> יהיו קטנים ככל האפשר, ויתחלקו בראשוניים מתוך קבוצת ראשוניים ידועה לנו – לקבוצה זו נקרא "בסיס הגורמים" ונסמן אותה ב-<math>B</math>. גודלה של הקבוצה <math>B</math> משפיע על ביצועי האלגוריתם, ולכל גרסה של הניפוי הריבועי יש לחשב את ה-<math>B</math> האופטימלי לפי גודלו של <math>n</math>.

לצורך הצגת האלגוריתם, נסמן <math>B=\{p_1,\ldots,p_k\}</math>, המספרים הראשוניים הקטנים, לפי סדרם. כדי ש-<math>Q(x)</math> יהיה קטן אנחנו צריכים לבחור <math>x</math> קטן, ואז <math>Q(x)\sim2\sqrt{n}x</math>. נבחר אפוא את טווח הניפוי <math>[1,M]</math>.

===שיפורים אפשריים===
א. אם נוסיף לבסיס הגורמים גם את 1-, אז מספרים הקרובים ל-<math>n</math> מלמטה גם הם מספרים קטנים יחסית, וניתן לבחור <math>x<0</math> ועדיין לקבל מספרים שקל יחסית לעבוד איתם. כך הכפלנו את טווח הניפוי ל-<math>[-M,M]</math>.

ב. את בסיס הגורמים אפשר להקטין על ידי "בדיקת היתכנות": אם <math>p\mid Q(x)</math> אז <math>(x+\sqrt{n})^2=Q(x)+n\equiv n\!\!\!\pmod{p}</math>, ולכן צריך להכניס לבסיס הגורמים רק מספרים ראשוניים המקיימים, עבור <math>x</math> מתוך טווח הניפוי, את התנאי <math>(x+\sqrt{n})^2\equiv n\!\!\!\pmod{p}</math>. זוהי בדיקה שאפשר להשלים בסיבוכיות נמוכה, לפי משפט ההיפוך הריבועי של גאוס, שמאפשר לחשב את סימן לז'נדר בזמן לוגריתמי (בדומה לחישוב המחלק המשותף המקסימלי באלגוריתם אוקלידס).

==הניפוי – Sieving==
הגדרה: המספר <math>x</math> הוא חלק מעל הקבוצה <math>B</math>, אם כל הגורמים הראשוניים של <math>x</math> נמצאים ב-<math>B</math>.

בשלב הניפוי אנחנו מחפשים <math>Q(x)</math> שיכולים להיות חלק מקבוצה המרכיבה מכפלה שהיא מספר ריבועי. לשם כך אנחנו צריכים לעבור על <math>x</math> מתוך טווח הניפוי, לחשב את <math>Q(x)</math> ולבדוק האם <math>Q(x)</math> חלק מעל <math>B</math>. עבור כל אחד מהמספרים שמתקבלים, אנו צריכים לבדוק אם הוא חלק על ידי מעבר וחלוקה בבסיס הגורמים. פעולה סדרתית כזו אינה מעשית מבחינת זמן ביצוע. לכן נעבוד על בסיס הגורמים במקביל.

לכל <math>p</math> בבסיס הגורמים אם <math>p\mid Q(x)</math> אז גם <math>p\mid Q(x+p)</math>. ובכיוון ההפוך, אם <math>x\equiv y\!\!\!\pmod{p}</math> אז גם <math>Q(x)\equiv Q(y)\!\!\!\pmod{n}</math>.

לכל <math>p</math> נפתור <math>Q(x)=s^2\equiv0\!\!\!\pmod{p},\ x\in\Z_p</math>. את המשוואה הזאת ניתן לפתור על ידי האלגוריתם של Shanks-Tonelli.
פתרון המשוואה הריבועית יתן לנו שני שורשים, נסמן אותם <math>S_1p,S_2p=p-S_1p</math>. מכאן אנו רואים כי <math>Q(x_i)</math> עבור <math>x_i</math> מתוך טווח החיפוש מתחלק ב-<math>p</math> כאשר <math>x_i=S_1p,S_2p+pk</math> עבור <math>k</math> שלם.

כעת בתהליך שמזכיר מאוד את מכונת השרשראות של להמר, אנחנו מתקדמים ולכל <math>x</math> אנחנו בודקים באלו ראשוניים מבסיס הגורמים <math>Q(x)</math> מתחלק. כדי לבצע את החיפוש הזה על כל טווח הניפוי כדאי לחלק את העבודה למספר מחשבים במקביל – וכל מחשב יקבל חלק מטווח הניפוי. אנחנו בודקים האם <math>Q(x)</math> הוא חלק, אם לא – נפטרים ממנו ועוברים ל-<math>x</math> הבא, ואם כן שומרים אותו בתוך מטריצה שתוגדר בהמשך.

===שיפורים אפשריים===
פעולת חילוק היא פעולה מורכבת. לכן במקום לעשות חישוב מדויק, כדי לבדוק במהירות את ה”חלקות” של <math>Q(x)</math> נבצע הערכה באמצעות מספר הביטים של הגורמים ש-<math>Q(x)</math> מתחלק בהם, וכך במהירות גבוהה נקבל תוצאות וודאיות במרבית המקרים, ובאלה שיש לגביהם ספק – נפטרים מהם ועוברים הלאה, לא חסרים לנו מספרים לבדוק.

==שלב המטריצה==
בשלב זה אנחנו מחזיקים קבוצה <math>Q</math> של מספרים גדולים <math>Q(x_i)</math> – ואנו צריכים למצוא קבוצה חלקית ל-<math>Q</math> כך שמכפלת האיברים של הקבוצה החלקית תתן מספר ריבועי. לשם כך נגדיר ווקטור של חזקות שמייצג מספרים חלקים מעל בסיס הראשוניים שלנו <math>B</math>.

עבור <math>m</math> מספר חלק מעל <math>B</math>: <math>m=\prod_{i\,=\,1}^kp_i^{v_i}\implies v(m)=(v_1,v_2,\ldots,v_k)</math>

אנחנו צריכים למצוא קבוצת וקטורים המייצגים מספרים מתוך <math>Q</math> כך שמכפלת המספרים תהיה מספר ריבועי. לשם כך אנחנו צריכים למצוא קבוצת וקטורי חזקות שסכומם יתן וקטור שכל איבריו זוגיים.

נבנה מטריצה V של וקטורי חזקות, המייצגים <math>Q(x)</math> חלקים מעל <math>B</math>. ועכשיו אנו צריכים למצוא וקטור בינארי <math>\vec e</math> שהכפלתו במטריצה תתן וקטור שכל איבריו זוגיים. על ידי דירוג מטריצות ניתן לפתור את המטריצה, ולקבל וקטור <math>\vec e</math> מתאים.

===שיפורים אפשריים===
כדי לעשות זאת קל יותר לחישוב נמיר את המטריצה <math>V</math> למטריצה בינארית <math>V_2</math>. ואז וקטור <math>\vec{e}\ne0</math> שמקיים <math>V_2\cdot\vec{e}=0</math> יהווה פתרון גם עבור המטריצה <math>V</math>.
חשוב לציין שווקטורים מודולו 2 אינם ייצוג חד-חד-ערכי של וקטורי חזקות – אולם החסכון בזמן חישוב ובגודל הזיכרון – אף שהוא ליניארי בלבד – משתלם למרות הצורך בהחזקת מיפוי בין הווקטור הבינארי למספר המקורי שהוא מייצג.

===דוגמאות לייצוג וקטורי מעל בסיס B===
<math>\begin{align}B=\bigl\{2,3,5,7,11,13,17\bigr\}\implies p_k=17\\\\
\begin{matrix}3\,651\,921&=&2^0\cdot3^2\cdot5^0\cdot7^4\cdot11^0\cdot13^2\cdot17^0&=&v(0,2,0,4,0,2,0)&\equiv& v(0,0,0,0,0,0,0)\pmod{2}\\11\,662&=&2^1\cdot3^0\cdot5^0\cdot7^3\cdot11^0\cdot13^0\cdot17^1&=&v(1,0,0,3,0,0,1)&\equiv& v(1,0,0,1,0,0,1)\pmod{2}\\1071&=&2^0\cdot3^2\cdot5^0\cdot7^1\cdot11^0\cdot13^0\cdot17^1&=&v(0,2,0,1,0,0,1)&\equiv& v(0,0,0,1,0,0,1)\pmod{2}\end{matrix}\end{align}</math>

==סיבוכיות==
סיבוכיות הנפה הריבועית תלויה בגודל הבסיס <math>B</math>. בסיס ראשוניים הכולל את כל הראשוניים עד <math>n</math> יביא לכך שכל <math>Q(x)</math> הוא חלק מעל <math>B</math>, וכך תהיה הסיבוכיות למציאת <math>Q(x)</math> מתאים <math>O(1)</math> בלבד. אולם, גודלה של המטריצה במקרה כזה (כ-<math>\frac{n}{\log(n)}</math>) אינו מאפשר לנו ליהנות מהיעילות של השלב הראשון. מצד שני, בסיס ראשוניים קטן מאוד (למשל הראשוניים עד 1000) ייצר לנו מטריצה קטנה ונוחה לפתרון, ועל כך נשלם בסיכוי זעיר למצוא <math>Q(x)</math> חלק מעל <math>B</math>.

נסמן ב-<math>\varphi(x,B)</math> את מספר המספרים החלקים מעל <math>B</math> בטווח <math>[1,x]</math>. הסיכוי שמספר אקראי בתחום זה יהיה חלק מעל <math>B</math> הוא <math>\frac{\varphi(x,B)}{x}</math>, ולכן כדי למצוא מספר אחד מתאים אנחנו צריכים לעבור על <math>\frac{x}{\varphi(x,B)}</math> מספרים אקראיים. חשוב להדגיש שהמספרים <math>Q(x)</math> אינם אקראיים במובן הפורמלי, אך כל הניתוחים ההיוריסטיים של שיטות הפירוק נעשים בהנחה שהם אקראיים במידה מספקת. כיוון שאנחנו צריכים <math>|B|=k</math> מספרים כאלו לבניית המטריצה (כדי להבטיח פתרון לא טריוויאלי), אנחנו צריכים לעבור על <math>k\frac{x}{\varphi(x,B)}</math> מספרים. עלות הבדיקה שמועמד <math>Q(x)</math> הוא חלק מעל <math>B</math> היא ליניארית ב-<math>B</math>, ולכן העבודה הכוללת בייצור היא <math>k^2\frac{x}{\varphi(x,B)}</math> פעולות (של ניסיון חילוק מספר בגודל <math>\sqrt{n}</math> בראשוני קטן).

פומרנץ הראה שכדי לקבל את המינימום עבור הנוסחה הזו צריך שהאיבר הגדול ב-<math>B</math>, אותו סימנו <math>p_k</math>, יהיה קרוב ל-<math>\exp\left(0.5\sqrt{\log(x)\log(\log(x))}\,\right)</math>, והעבודה הנדרשת היא <math>\exp\left(2\sqrt{\log(x)\log(\log(x))}\,\right)</math>, כלומר כ- <math>p_k^4</math>.

אבל מהו <math>x</math>?
באלגוריתם הניפוי הריבועי אנחנו מייצרים <math>Q(x)</math> מסדר גודל של <math>n^{0.5+\varepsilon}</math> כאשר <math>\varepsilon</math> קטן מאוד (מכיוון שמספר המועמדים שנבדוק הוא חזקה קטנה של <math>n</math>); כלומר <math>x=n^{0.5+\varepsilon}</math>. לכן סדר הגודל של שלב הניפוי הוא <math>\exp\left(2\sqrt{\log(x)\log(\log(x))}\,\right)</math>.

לאחר שהנתונים נאספו במטריצה בגודל <math>k\times k</math>, צריך למצוא פתרון לא טריוויאלי, בעלות של <math>O(k^3)</math>. למעשה החלק הזה של האלגוריתם הוא מהיר בהרבה, מכיוון שהמטריצה דלילה. בכל אופן מדובר בסיבוכיות זניחה ביחס לשלב איסוף המשוואות.

==נפת שדה המספרים מול הנפה הריבועית==
שיטה נוספת לפירוק מספר לגורמים היא נפת שדה המספרים (Number Field Sieving), זוהי שיטה מהירה יותר אסימפטוטית מהנפה הריבועית (Quadratic Sieve), אך מסובכת הרבה יותר.

שתי השיטות מחולקות לשני שלבים: שלב הניפוי ושלב מטריצה.

סדר הגודל של שלב הניפוי בנפת שדה המספרים הוא <math>\exp\left(c\sqrt[3]{\log(n)\log(\log(n))^2}\,\right)</math>, כאשר <math>c</math> משתנה לפי סוג הניפוי המדויק בו משתמשים (ברוב המימושים <math>1.5\le c\le2</math>).

אסימפטוטית זהו סדר גודל קטן יותר משל הנפה הריבועית, אבל במספרים "קטנים" (עד 100 ספרות) עדיף להשתמש בנפה הריבועית בגלל המסובכות של נפת שדה המספרים.

==מקורות==
*Landquist, E., “MATH 488: Cryptographic Algorithms”, “The Quadratic Sieve Factoring Algorithm”, December 14, 2001
*Pomerance, C., “A Tale of Two Sieves”, December, 1996.

==ראו גם==
*TWINKLE – מכשיר אלקטרואופטי תאורטי, המממש את שיטת הנפה הריבועית לפירוק מהיר לגורמים.

==קישורים חיצוניים==
*[https://web.archive.org/web/20090823192015/http://www.math.uiuc.edu/~landquis/quadsieve.pdf The Quadratic Sieve Factoring Algorithm]
*[http://www.ams.org/notices/199612/pomerance.pdf A Tale of Two Sieves]
*

קטגוריה:תורת המספרים
קטגוריה:מספרים ראשוניים
קטגוריה:שיטות פירוק לגורמים