אלגוריתם רו של פולרד ללוגריתם הבדיד

בתורת המספרים ובקריפטוגרפיה, אלגוריתם רו של פולרד ללוגריתם הבדיד (באנגלית: Pollard’s rho algorithm for discrete logarithms) הוא אלגוריתם הסתברותי לחישוב לוגריתם בדיד בחבורה ציקלית סופית מסדר ראשוני עם זמן ריצה דומה לשיטת כוח גס גנרית הנקראת אלגוריתם צעד-קטן צעד-גדול אך עם צריכת זיכרון שולית ביחס אליה. האלגוריתם פותר את בעיית הלוגריתם הבדיד בהסתברות גבוהה, בסיבוכיות בסדר גודל של O ( n ) {\displaystyle O({\sqrt {n}})} כאשר n {\displaystyle n} הוא סדר החבורה. לצורך אלגוריתם פולרד ההנחה היא שסדר החבורה הוא מספר ראשוני, שאם לא כן, אפשר בשילוב עם אלגוריתם פוליג-הלמן לפתור את בעיית הלוגריתם הבדיד בזמן ריצה שהוא בסדר גודל O ( p ) {\displaystyle O({\sqrt {p}})} כאשר p {\displaystyle p} הוא הגורם הראשוני הגדול ביותר של n {\displaystyle n} . אלגוריתם רו הומצא על ידי המתמטיקאי הבריטי ג'ון פולרד והתפרסם במאמר "שיטת מונטה קרלו לחישוב אינדקסים" בכתב העת המדעי "Mathematics of Computation" ביולי 1978. בדומה לאלגוריתם רו של פולרד לפירוק לגורמים הוא נקרא בשם זה בשל העובדה שבמיפוי אקראי (או הילוך מקרי) בקבוצה סופית, נוצר מעין "מעגל" אליו מחובר "שובל" קצר וצורתו דומה במקצת לאות היוונית ρ {\displaystyle \rho } (כמתואר בתרשים משמאל), כלומר בהינתן פונקציה אקראית לאחר מספר מוגבל של ערכים מגיעים לנקודה בה הערכים מתחילים לחזור על עצמם במעגל אין סופי. הרעיון של פולרד ניתן להרחבה לכל סוג של חבורה ציקלית, כמו חבורה אבלית מעל עקום אליפטי הידועה בפופולריות שלה בהצפנה המודרנית ולמעשה לא ידוע על אלגוריתם שמציג סיבוכיות טובה יותר לפתרון בעיית הלוגריתם הבדיד בעקום אליפטי. בחבורה ציקלית מעל מספר ראשוני קיים אלגוריתם תחשיב אינדקסים עם זמן ריצה תת-מעריכי והוא נחשב ליעיל ביותר הידוע כיום למספרים גדולים אך אינו בר ביצוע בעקום אליפטי. ב-1980 פיתח ריצ'רד ברנט גרסה משופרת יותר של אלגוריתם רו של פולרד לפירוק לגורמים שניתן ליישום גם לפתרון בעיית הלוגריתם הבדיד ומציע שיפור בפקטור של רבע ביעילותו לעומת הגרסה של פולרד. מאוחר יותר פולרד וברנט פיתחו ושיפרו את האלגוריתם אף יותר. ערך מורחב – בעיית הלוגריתם הבדיד ביטחון מערכות הצפנה מודרניות רבות מסתמך על ההשערה שקשה לפתור את בעיית הלוגריתם הבדיד (דיסקרטי) בחבורות מסוימות. בהסתמך על בעיה זו ניתן להכין פונקציה חד-כיוונית שהיא הבסיס להצפנה אסימטרית. הדוגמאות אולי החשובות ביותר הן פרוטוקול דיפי-הלמן וחתימה דיגיטלית DSA הפופולריים שמסתמכים על השערה זו, למרות שלא קיימת הוכחה מתמטית. בעיית הלוגריתם הבדיד המסומנת בקיצור DLP היא כדלקמן: בעיית דיפי-הלמן בקיצור DHP, היא בעיה דומה שהועלתה לראשונה על ידי ויטפילד דיפי ומרטין הלמן במאמר המפורסם שלהם שבו הציגו לראשונה את הצפנת מפתח ציבורי ופרוטוקול שיתוף מפתח המבוסס על הבעיה הבאה: נתון המספר הראשוני p {\displaystyle p} ויוצר α {\displaystyle \alpha } של החבורה Z p ∗ {\displaystyle \mathbb {Z} _{p}^{*}} וכן נתונים α x {\displaystyle \alpha ^{x}} ו- α y {\displaystyle \alpha ^{y}} (מודולו p {\displaystyle p} ). מצא את α x y {\displaystyle \alpha ^{xy}} מודולו p {\displaystyle p} . בעיה זו נחשבת גם היא לבעיה קשה אם כי לא הוכח האם היא קשה לפחות כבעיית הלוגריתם הבדיד. מאידך, כל דרך לפתרון בעיית הלוגריתם הדיקסרטי יכולה לשמש לפתרון בעיית דיפי-הלמן. לדוגמה אם נתון המספר הראשוני p = 97 {\displaystyle p=97} החבורה Z 97 ∗ {\displaystyle \mathbb {Z} _{97}^{*}} היא חבורה ציקלית מסדר n = 96 {\displaystyle n=96} . יוצר אפשרי אחד של חבורה זו יכול להיות α = 5 {\displaystyle \alpha =5} . (קל לראות שאם מעלים את 5 בחזקת כל המספרים מ-1 עד 96 (מודולו 97) מתקבלים כל האלמנטים של החבורה בלי יוצא מן הכלל לא בהכרח לפי סדר עולה). אם נבחר x = 32 {\displaystyle x=32} בחשבון פשוט מתקבל 5 32 ≡ 35  (mod  97 ) {\displaystyle 5^{32}\equiv 35{\text{ (mod }}97)} לכן log 5 ⁡ 35 = 32 {\displaystyle \log _{5}35=32} בחבורה Z 97 ∗ {\displaystyle \mathbb {Z} _{97}^{*}} . וכן, אם y = 17 {\displaystyle y=17} אז 5 17 ≡ 83  (mod  97 ) {\displaystyle 5^{17}\equiv 83{\text{ (mod }}97)} . אם נתונים האלמנטים 5 32 ≡ 35 {\displaystyle 5^{32}\equiv 35} ו- 5 17 ≡ 83 {\displaystyle 5^{17}\equiv 83} (מודולו 97) בעיית דיפי-הלמן היא לגלות את 5 32 ⋅ 17 ≡ 61  (mod  97 ) {\displaystyle 5^{32\cdot 17}\equiv 61{\text{ (mod }}97)} (כשהאלמנטים x {\displaystyle x} ו- y {\displaystyle y} אינם ידועים). הבעיה נקראת לוגריתם בדיד כיוון שהיא עוסקת בקבוצה סופית מודולו שלם כלשהו הנקרא מודולוס. ראוי לציין שאף-על-פי שקל לחשב לוגריתמים באופן כללי, אין הדבר נכון לגבי לוגריתם בדיד מכיוון שהתנהגות התוצאה נראית אקראית על פניה ולא ניתן לבצע קירוב. הסיבה שהבסיס הוא יוצר היא כדי שהחבורה תהיה ציקלית כך שכל אלמנט בחבורה ניתן לייצוג כחזקה של היוצר. הדרישה שהחבורה תהיה ציקלית אינה הכרחית, הגדרה כללית יותר של הבעיה, הנקראת בקיצור GDLP, היא מציאת אלמנט x {\displaystyle x} המקיים α x = β {\displaystyle \alpha ^{x}=\beta } , בהנחה שקיים, עבור האלמנטים α , β ∈ G {\displaystyle \alpha ,\beta \in G} (כאשר α {\displaystyle \alpha } אינו בהכרח יוצר). החבורה החיבורית הנוצרת על ידי עקום אליפטי כאשר הפעולה היא חיבור נקודות בעקום היא דוגמה לחבורה שבה בעיית הלוגריתם הבדיד קשה. אחת הדרכים לפתור את הבעיה היא בעצם חישוב איזומורפיזם בין חבורות. אפילו אם שתי חבורות איזומורפיות זו לזו, אלגוריתם יעיל לפתרון בעיית הלוגריתם הבדיד בחבורה אחת, אינו בהכרח יעיל בחבורה השנייה. למשל כל חבורה כפלית ציקלית מסדר n {\displaystyle n} איזומורפית לחבורה החיבורית הציקלית Z n {\displaystyle \mathbb {Z} _{n}} . על כל פנים, בעוד שקיים אלגוריתם יעיל לחישוב לוגריתמים בחבורה החיבורית מעל המספרים השלמים מודולו מספר ראשוני, כלומר מציאת שלם המקיים a x ≡ b  (mod  n ) {\displaystyle ax\equiv b{\text{ (mod }}n)} , לא ניתן ליישמו לפתרון הלוגריתם הבדיד בחבורה הכפלית. הדרך הישירה והפשוטה ביותר לפתרון בעיית הלוגריתם הבדיד היא שיטת כוח גס, סריקת כל החזקות של α {\displaystyle \alpha } בזה אחר זה מ-1 עד n {\displaystyle n} עד שמתקבל β {\displaystyle \beta } וסיבוכיותה היא מסדר גודל O ( n ) {\displaystyle O(n)} . היא אינה יעילה מהיבט קריפטוגרפי כיוון שאם n {\displaystyle n} גדול (נניח באורך n ≥ 2 128 {\displaystyle n\geq 2^{128}} סיביות) התקפה כזו אינה פרקטית. שיטה מעט יותר טובה נקראת "צעד-קטן צעד-גדול" והיא מבוססת על העובדה שאם β = α x {\displaystyle \beta =\alpha ^{x}} אפשר לכתוב את x {\displaystyle x} בצורה: x = i m + j {\displaystyle x=im+j} (לפי כלל החילוק המודולרי) כאשר j < m {\displaystyle j<m} ו- m = ⌈ n ⌉ {\displaystyle m=\left\lceil {\sqrt {n}}\right\rceil } . לכן α x = α i m α j {\displaystyle \alpha ^{x}=\alpha ^{im}\alpha ^{j}} לאחר העברת אגפים מתקבל β ( α − m ) i = α j {\displaystyle \beta (\alpha ^{-m})^{i}=\alpha ^{j}} . מהאמור עולה שאם מכינים טבלה המכילה את הזוגות ( j , α j {\displaystyle j,\alpha ^{j}} ) עבור כל המספרים מ-1 עד m {\displaystyle m} , הממויינת לפי האלמנט השני, מובטח שיימצא אלמנט אחד (אם קיים פתרון) השווה ל- β ( α − m ) i {\displaystyle \beta (\alpha ^{-m})^{i}} . היות שהטבלה היא בסדר גודל של השורש הריבועי של סדר החבורה וחיפוש בטבלה ממויינת אינו קשה, יוצא שסיבוכיות השיטה היא O ( n ) {\displaystyle O({\sqrt {n}})} אך היא דורשת סיבוכיות מקום בסדר גודל של O ( n ) {\displaystyle O({\sqrt {n}})} ועל כן אם n {\displaystyle n} גדול מאוד (נניח n ≥ 2 128 {\displaystyle n\geq 2^{128}} ) היא אינה פרקטית. אלגוריתם רו של פולרד מנסה לייצר "סדרה פסידו-אקראית" של אלמנטים מהחבורה בהתבסס על רעיון מונטה קרלו וחיפוש אחר התנגשויות, כלומר שני אלמנטים זהים בסדרה. אם נמצאה התנגשות הדבר מוביל לפתרון בעיית הלוגריתם הבדיד בהסתברות גבוהה. שני רעיונות מרכזיים של פולרד הם פונקציה איטרטיבית אקראית קלה לחישוב, איתה מכינים את הסדרה הפסאודו-אקראית ואלגוריתם מציאת מחזוריות שמנסה למצוא בה התנגשות בזמן הקצר ביותר ללא שימוש בטבלאות. לצורך הפשטות נניח שנתונה חבורה ציקלית G {\displaystyle G} מסדר n {\displaystyle n} ראשוני. תחילה מחלקים את G {\displaystyle G} לשלוש קבוצות בגודל זהה בקירוב S 1 , S 2 , S 3 {\displaystyle S_{1},S_{2},S_{3}} , בחלוקה לוגית בהתבסס על כלל מנחה קל לבדיקה. אפשר למשל לחלק לפי משקלו של כל אלמנט באופן הבא הקבוצה S 1 {\displaystyle S_{1}} תכיל את כל האלמנטים: 0 < x i < 1 3 n {\displaystyle \textstyle 0<x_{i}<{\frac {1}{3}}n} , הקבוצה S 2 {\displaystyle S_{2}} את האלמנטים 1 3 n < x i < 2 3 n {\displaystyle \textstyle {\frac {1}{3}}n<x_{i}<{\frac {2}{3}}n} והשלישית 2 3 n < x i < n {\displaystyle \textstyle {\frac {2}{3}}n<x_{i}<n} . דרך אחרת יותר יעילה היא לחלק לפי הערך של t {\displaystyle t} הסיביות הכי פחות משמעותיות של כל x i {\displaystyle x_{i}} כאשר t {\displaystyle t} תלוי במספר החלוקות (במקרה זה מספיק לבחון את שתי הסיביות האחרונות). מספר החלוקות שרירותי וניתן לשינוי, אך יש צורך לשים לב לכמה היבטים חשובים בנוגע לחלוקה למשל 1 ∉ S 2 {\displaystyle 1\notin S_{2}} . מחשבים סדרה פסידו-אקראית של אלמנטים מהחבורה לפי הכלל הבא. בוחרים אלמנט התחלתי x 0 = 1 {\displaystyle x_{0}=1} ועבור כל i ≥ 0 {\displaystyle i\geq 0} מחשבים: x i + 1 = f ( x i ) = d e f { β ⋅ x i ,  if  x i ∈ S 1 x i 2 ,  if  x i ∈ S 2 α ⋅ x i ,  if  x i ∈ S 3 {\displaystyle x_{i+1}=f(x_{i}){\overset {\underset {\mathrm {def} }{}}{=}}{\begin{cases}\beta \cdot x_{i},&{\mbox{ if }}x_{i}\in S_{1}\\x_{i}^{2},&{\mbox{ if }}x_{i}\in S_{2}\\\alpha \cdot x_{i},&{\mbox{ if }}x_{i}\in S_{3}\end{cases}}} בנוסף מתוך הסדרה האמורה מכינים שתי רשימות של שלמים a 0 , a 1 , a 2 , . . . {\displaystyle a_{0},a_{1},a_{2},...} וכן b 0 , b 1 , b 2 , . . . {\displaystyle b_{0},b_{1},b_{2},...} כאשר a 0 = 0 {\displaystyle a_{0}=0} ו- b 0 = 0 {\displaystyle b_{0}=0} ועבור כל i ≥ 0 {\displaystyle i\geq 0} מחשבים את a i + 1 = { a i ,  if  x i ∈ S 1 2 a i  mod  n ,  if  x i ∈ S 2 a i + 1  mod  n ,  if  x i ∈ S 3 {\displaystyle a_{i+1}={\begin{cases}a_{i},&{\mbox{ if }}x_{i}\in S_{1}\\2a_{i}{\text{ mod }}n,&{\mbox{ if }}x_{i}\in S_{2}\\a_{i}+1{\text{ mod }}n,&{\mbox{ if }}x_{i}\in S_{3}\end{cases}}} וכן b i + 1 = { b i + 1  mod  n ,  if  x i ∈ S 1 2 b i  mod  n ,  if  x i ∈ S 2 b i ,  if  x i ∈ S 3 {\displaystyle b_{i+1}={\begin{cases}b_{i}+1{\text{ mod }}n,&{\mbox{ if }}x_{i}\in S_{1}\\2b_{i}{\text{ mod }}n,&{\mbox{ if }}x_{i}\in S_{2}\\b_{i},&{\mbox{ if }}x_{i}\in S_{3}\end{cases}}} הערכים של a i {\displaystyle a_{i}} ו- b i {\displaystyle b_{i}} מחושבים כך שעבור כל i {\displaystyle i} מתקיים x i = α a i ⋅ β b i {\displaystyle x_{i}=\alpha ^{a_{i}}\cdot \beta ^{b_{i}}} . אם x i = x j {\displaystyle x_{i}=x_{j}} כאשר i ≠ j {\displaystyle i\neq j} זה אומר שנמצאה "התנגשות". כדי למצוא התנגשות ביעילות האלגוריתם מנצל טכניקה המיוחסת לרוברט פלויד (לפי דונלד קנות') שנקראת מציאת מחזוריות או "שיטת הצב והארנב" שהיא שיטה יעילה לאיתור מחזוריות של פונקציה איטרטיבית אקראית על עצמה מהצורה f : X → X {\displaystyle f:X\rightarrow X} . מנסים באופן רקורסיבי לאתר את הנקודה בה הסדרה מתחילה לחזור על עצמה. מבצעים בכל איטרציה שתי הליכות, הליכה איטית והליכה מהירה. בהליכה איטית מחשבים מתוך הערכים מהאיטרציה הקודמת את השלשה החדשה ( x i , a i , b i {\displaystyle x_{i},a_{i},b_{i}} ) ובהליכה מהירה את ( x 2 i , a 2 i , b 2 i ) {\displaystyle (x_{2i},a_{2i},b_{2i})} ומשווים בין x i {\displaystyle x_{i}} ל- x 2 i {\displaystyle x_{2i}} , אם הם שווים אותרה מחזוריות הפונקציה וזה אומר שמנקודה זו ואילך המסלול יחזור על עצמו במעגל אין סופי. סיבוכיות הטכניקה הזו זהה לשיטה הישירה המסתמכת על חיפוש בטבלאות ומבזבזת זיכרון רב. אם נמצאה התאמה המשמעות היא ש- α a i β b i = α a 2 i β b 2 i {\displaystyle \alpha ^{a_{i}}\beta ^{b_{i}}=\alpha ^{a_{2i}}\beta ^{b_{2i}}} ולכן β b i − b 2 i = α a 2 i − a i {\displaystyle \beta ^{b_{i}-b_{2i}}=\alpha ^{a_{2i}-a_{i}}} . אם לוקחים לוגריתם בבסיס α {\displaystyle \alpha } של שני האגפים במשוואה האחרונה מתקבל ( b i − b 2 i ) ⋅ log α ⁡ β ≡ ( a 2 i − a i )  (mod  n ) {\displaystyle (b_{i}-b_{2i})\cdot \log _{\alpha }\beta \equiv (a_{2i}-a_{i}){\text{ (mod }}n)} . בהנחה ש- b i ≢ b 2 i  (mod  n ) {\displaystyle b_{i}\not \equiv b_{2i}{\text{ (mod }}n)} , שבכל מקרה עלול לקרות בהסתברות מאוד זניחה. מתוך המשוואה האחרונה אפשר לחלץ את log α ⁡ β {\displaystyle \log _{\alpha }\beta } על ידי הכפלה בהופכי הכפלי של ( b i − b 2 i ) {\displaystyle (b_{i}-b_{2i})} . אלגוריתם רו של פולרד קלט: החבורה G {\displaystyle G} מסדר n {\displaystyle n} , יוצר α {\displaystyle \alpha } והאלמנט β {\displaystyle \beta } . פלט: הלוגריתם הבדיד x = log α ⁡ β {\displaystyle x=\log _{\alpha }\beta } . מציבים x 0 = 1 , a 0 = 0 , b 0 = 0 {\displaystyle x_{0}=1,a_{0}=0,b_{0}=0} . מבצעים לולאה עם i = 1 , 2 , 3 , . . . {\displaystyle i=1,2,3,...} מחשבים את הערכים של x i , a i , b i {\displaystyle x_{i},a_{i},b_{i}} מתוך הערכים הקודמים x i − 1 , a i − 1 , b i − 1 {\displaystyle x_{i-1},a_{i-1},b_{i-1}} וכן x 2 i − 2 , a 2 i − 2 , b 2 i − 2 {\displaystyle x_{2i-2},a_{2i-2},b_{2i-2}} לפי הנוסחאות המתוארות לעיל. אם x i = x 2 i {\displaystyle x_{i}=x_{2i}} מבצעים: מציבים r = b i − b 2 i  mod  n {\displaystyle r=b_{i}-b_{2i}{\text{ mod }}n} אם r = 0 {\displaystyle r=0} אלגוריתם מסתיים בכישלון אחרת מחזירים את x = r − 1 ( a 2 i − a i )  mod  n {\displaystyle x=r^{-1}(a_{2i}-a_{i}){\text{ mod }}n} . במקרה הנדיר שהאלגוריתם מסתיים בכישלון מגרילים a 0 , b 0 {\displaystyle a_{0},b_{0}} אחרים ומתחילים מההתחלה כאשר x 0 = α a 0 β b 0 {\displaystyle x_{0}=\alpha ^{a_{0}}\beta ^{b_{0}}} . נתונה תת-חבורה G {\displaystyle G} של החבורה Z 383 ∗ {\displaystyle \mathbb {Z} _{383}^{*}} מסדר n = 191 {\displaystyle n=191} עם היוצר α = 2 {\displaystyle \alpha =2} ונתון β = 228 {\displaystyle \beta =228} . חלוקת האלמנטים של G {\displaystyle G} לשלוש קבוצות מתבצעת לפי הכלל הבא: מחשבים את x  mod  3 {\displaystyle x{\text{ mod }}3} , אם השארית 1 הוא שייך ל- S 1 {\displaystyle S_{1}} , אם השארית היא 0 הוא שייך ל- S 2 {\displaystyle S_{2}} ואילו אם השארית היא 2 הוא שייך ל- S 3 {\displaystyle S_{3}} . הטבלה הבאה מסכמת את מהלכי האלגוריתם והערכים של x i , a i , b i {\displaystyle x_{i},a_{i},b_{i}} וכן x 2 i , a 2 i , b 2 i {\displaystyle x_{2i},a_{2i},b_{2i}} לאחר כל איטרציה. באיטרציה ה-14 נמצאה התנגשות כי x 14 = x 28 = 144 {\displaystyle x_{14}=x_{28}=144} . לכן מחשבים את r = 38 − 104 = 125  (mod  191 ) {\displaystyle r=38-104=125{\text{ (mod }}191)} וההופכי שלו 125 − 1 ≡ 136  (mod  191 ) {\displaystyle 125^{-1}\equiv 136{\text{ (mod }}191)} ולכן 136 ⋅ ( 10 − 12 ) ≡ 110  (mod  191 ) {\displaystyle 136\cdot (10-12)\equiv 110{\text{ (mod }}191)} והפתרון הוא log 2 ⁡ 228 = 110 {\displaystyle \log _{2}228=110} מודולו 191. עקום אליפטי הוא כלי מתמטי פופולרי המצוי בשימוש נרחב בהצפנה מודרנית בשל העובדה שהוא מאפשר פרמטרים קטנים יותר בפקטור של עשר בקירוב לעומת אלגוריתם כמו RSA. עם עקום אליפטי אפשר ליישם פונקציה חד-כיוונית ואיתה לממש הצפנה אסימטרית המבוססת על בעיה מתמטית כמו בעיית הלוגריתם הבדיד בעקום אליפטי. בעיית הלוגריתם הבדיד בעקום אליפטי מקבילה לבעיה הכללית והיא כדלהלן: השלם l {\displaystyle l} נקרא הלוגריתם הבדיד של הנקודה Q {\displaystyle Q} בבסיס הנקודה P {\displaystyle P} או בקיצור l = log P ⁡ Q {\displaystyle l=\log _{P}Q} . אם הפרמטרים של העקום E {\displaystyle E} נבחרו בזהירות כדי להבטיח שלא יהיו קיצורי דרך לפתרון הבעיה בעקום זה, הדרך הטובה ביותר לפתרונה היא באמצעות אלגוריתם רו של פולרד בסיבוכיות של n {\displaystyle {\sqrt {n}}} . הסימון ⟨ P ⟩ {\displaystyle \langle P\rangle } מייצג את כל הנקודות שהן כפולות של P {\displaystyle P} . (כגון P , 2 P , 3 P , 4 P , . . . {\displaystyle P,2P,3P,4P,...} וכן הלאה עד n {\displaystyle n} ). במילים אחרות, הנקודה Q {\displaystyle Q} היא תוצאה של חיבור הנקודה P {\displaystyle P} בעצמה (הנקראת בקיצור POINT_DBL) בדיוק l {\displaystyle l} פעמים והבעיה היא לגלות כמה פעמים בוצע החיבור, קרי לגלות את ערכו של l {\displaystyle l} . לא קיימת דרך פשוטה לבצע זאת כי המסלול של הנקודות נראה אקראי. שיטת כוח גס אינה מעשית משום שבמקרה הממוצע יש צורך לבדוק לפחות מחצית מהנקודות עד שנמצא l P {\displaystyle lP} . אם n ≥ 2 128 {\displaystyle n\geq 2^{128}} כוח גס אינו מעשי. כמובן שיש לשים לב של- n {\displaystyle n} יש לפחות גורם ראשוני אחד גדול דיו. שאם לא כן אפשר לנצל את אלגוריתם פוליג-הלמן בזמן שהוא ביחס ישיר לגודל הגורמים הראשוניים שלו. למעשה ככל שהגורם הראשוני שלו (לפחות אחד מהם) גדול יותר סיבוכיות ההתקפה תהיה גבוהה יותר. כמו בחבורה ציקלית, הרעיון של אלגוריתם רו בעקום אליפטי הוא למצוא שני זוגות שלמים ( c , d {\displaystyle c,d} ) וכן ( e , f {\displaystyle e,f} ) מודולו n {\displaystyle n} המקיימים: c P + d Q = e P + f Q {\displaystyle cP+dQ=eP+fQ} ואז ( c − e ) P = ( f − d ) Q = ( f − d ) l P {\displaystyle (c-e)P=(f-d)Q=(f-d)lP} ולכן ( c − e ) ≡ ( f − d ) l  (mod  n ) {\displaystyle (c-e)\equiv (f-d)l{\text{ (mod }}n)} מזה נובע שאפשר לחשב את l = log P ⁡ Q {\displaystyle l=\log _{P}Q} על ידי l = ( c − e ) ( f − d ) − 1  mod  n {\displaystyle l=(c-e)(f-d)^{-1}{\text{ mod }}n} . הדרך הישירה למצוא זוגות המקיימים את המשוואה האמורה היא על ידי בחירה אקראית ואחסון בטבלה. אם מכינים טבלה המכילה את כל השלשות: ( c , d , c P + d Q {\displaystyle c,d,cP+dQ} ) וממיינים לפי הערך השלישי, מובטח שבסופו של דבר הערך הזה יופיע פעם נוספת מה שיאפשר לגלות את הלוגריתם הבדיד כאמור. תופעה שבה הערך השלישי מופיע פעמיים כאשר הערכים האחרים שונים נקראת "התנגשות". לפי פרדוקס יום ההולדת מספר הניסיונות הצפוי לפני שתופיע התנגשות הוא בערך π n / 2 {\displaystyle \textstyle {\sqrt {\pi n/2}}} שזה בערך 1.2533 n {\displaystyle \textstyle 1.2533{\sqrt {n}}} . אולם החסרון בשיטה זו הוא שיש צורך בזיכרון רב, ליתר דיוק π n / 2 {\displaystyle \textstyle {\sqrt {\pi n/2}}} שלשות. אלגוריתם רו מנסה להימנע משימוש בזיכרון על ידי שיטת הצב והארנב. מגדירים פונקציה איטרטיבית אקראית ⟨ P ⟩ → ⟨ P ⟩ {\displaystyle \langle P\rangle \rightarrow \langle P\rangle } כך שבהינתן X ∈ ⟨ P ⟩ {\displaystyle X\in \langle P\rangle } והערכים c {\displaystyle c} ו- d {\displaystyle d} כך שמתקיים X = c P + d Q {\displaystyle X=cP+dQ} יהיה קל לחשב את X ¯ = f ( X ) {\displaystyle {\overline {X}}=f(X)} ואת c ¯ , d ¯ {\displaystyle {\overline {c}},{\overline {d}}} כך שמתקיים X ¯ = c ¯ P + d ¯ Q {\displaystyle {\overline {X}}={\overline {c}}P+{\overline {d}}Q} . לדוגמה, אם מחלקים את החבורה הציקלית ⟨ P ⟩ {\displaystyle \langle P\rangle } ל- L {\displaystyle L} רשימות בגודל זהה בקירוב (למשל L = 32 {\displaystyle L=32} ), מציבים כל נקודה X i {\displaystyle X_{i}} ברשימה המתאימה S j {\displaystyle S_{j}} אם הערך של 5 הסיביות הכי פחות משעותיות של הקואורדינטה x {\displaystyle x} של הנקודה X i {\displaystyle X_{i}} הוא j − 1 {\displaystyle j-1} . נניח ששיטת חלוקה זו תסומן ב- H ( X ) {\displaystyle H(X)} ונניח שהערכים a j {\displaystyle a_{j}} ו- b j {\displaystyle b_{j}} הם שלמים אקראיים כלשהם הנמוכים מ- n {\displaystyle n} כאשר j {\displaystyle j} מתפרס על פני כל הרשימות של L {\displaystyle L} , במקרה זה פונקציה אקראית איטרטיבית יכולה להיות: f ( X ) = X + a j P + b j Q {\displaystyle f(X)=X+a_{j}P+b_{j}Q} כאשר j = H ( X ) {\displaystyle j=H(X)} ולכן אם X = c P + d Q {\displaystyle X=cP+dQ} אז הפונקציה האקראית היא f ( X ) = X ¯ = c ¯ P + d ¯ Q {\displaystyle f(X)={\overline {X}}={\overline {c}}P+{\overline {d}}Q} כאשר c ¯ = c + a j  mod  n {\displaystyle {\overline {c}}=c+a_{j}{\text{ mod }}n} וכן d ¯ = d + b j  mod  n {\displaystyle {\overline {d}}=d+b_{j}{\text{ mod }}n} . כל נקודה התחלתית X 0 ∈ ⟨ P ⟩ {\displaystyle X_{0}\in \langle P\rangle } מגדירה סדרה אחרת { X i } i ≥ 0 {\displaystyle \{X_{i}\}_{i\geq 0}} של נקודות כאשר כל נקודה מחושבת על ידי הנקודה הקודמת, X i = f ( X i − 1 ) {\displaystyle X_{i}=f(X_{i-1})} . היות שהחבורה הזו סופית בהכרח שתיגרם התנגשות, כלומר ערך של X i {\displaystyle X_{i}} כלשהו יופיע שוב ומנקודה זו ואילך הסדרה תחזור על עצמה במעגל אין סופי. כלומר יופיע האינדקס הקטן ביותר t {\displaystyle t} המקיים X t = X t + s {\displaystyle X_{t}=X_{t+s}} עבור s {\displaystyle s} כלשהו ומכאן ואילך X i = X i − s {\displaystyle X_{i}=X_{i-s}} עבור כל i ≥ t + s {\displaystyle i\geq t+s} . כאן t {\displaystyle t} הוא אורך השובל ו- s {\displaystyle s} הוא היקף מעגל במונחים של מספר האיטרציות של הפונקציה האיטרטיבית האקראית. אם f {\displaystyle f} היא פונקציה אקראית אז ההתנגשות הראשונה צפויה לקרות לאחר π n / 2 {\displaystyle \textstyle {\sqrt {\pi n/2}}} צעדים בקירוב. אורך השובל הוא t ≈ π n / 8 {\displaystyle \textstyle t\approx {\sqrt {\pi n/8}}} ואורך המעגל צריך להיות s ≈ π n / 8 {\displaystyle \textstyle s\approx {\sqrt {\pi n/8}}} בקירוב. התנגשות היא מצב שבו X i = X j {\displaystyle X_{i}=X_{j}} כאשר i ≠ j {\displaystyle i\neq j} ואותה אפשר למצוא ללא צורך בזיכרון באמצעות שיטת פלויד או שיטת הצב והארנב. בשיטה זו מחשבים בכל צעד את הנקודות X i {\displaystyle X_{i}} ו- X 2 i {\displaystyle X_{2i}} ומנסים למצוא התאמה. מספר הזוגות הצפוי שיש לבדוק הוא לכל הפחות t {\displaystyle t} זוגות ולכל היותר t + s {\displaystyle t+s} זוגות, עד שתמצא התנגשות. ליתר דיוק בהנחה ש- f {\displaystyle f} אקראית מספר הזוגות הצפוי שצריך לבדוק עד שתמצא התנגשות הוא k = 1.0308 n {\displaystyle \textstyle k=1.0308{\sqrt {n}}} . מספר החישובים שיש לבצע בעקום האליפטי הוא בערך 3 n {\displaystyle \textstyle 3{\sqrt {n}}} פעולות חיבור נקודות. אלגוריתם רו של פולרד לחישוב לוגריתם בדיד בעקום אליפטי. קלט: הנקודה P ∈ E ( F q ) {\displaystyle P\in E(\mathbb {F} _{q})} מסדר n {\displaystyle n} והנקודה Q ∈ ⟨ P ⟩ {\displaystyle Q\in \langle P\rangle } פלט: הלוגריתם הבדיד l = log P ⁡ Q {\displaystyle l=\log _{P}Q} . תחילה בוחרים את מספר הענפים או רשימות L {\displaystyle L} ואת פונקציית החלוקה H {\displaystyle H} שמציבה כל נקודה ברשימה המתאימה לפי הכלל j {\displaystyle j} . עבור j = 1 {\displaystyle j=1} עד L {\displaystyle L} מבצעים: מגרילים שני שלמים a j , b j {\displaystyle a_{j},b_{j}} ומחשבים את R j = a j P + b j Q {\displaystyle R_{j}=a_{j}P+b_{j}Q} . מגרילים זוג שלמים נוספים c , d {\displaystyle c,d} ומחשבים את X ′ = c P + d Q {\displaystyle X'=cP+dQ} . מציבים X ″ = X ′ , e = c , f = d {\displaystyle X''=X',e=c,f=d} . חוזרים על המהלכים הבאים: j = H ( X ′ ) {\displaystyle j=H(X')} X ′ = X ′ + R j , c = c + a j , d = d + b j  (mod  n ) {\displaystyle X'=X'+R_{j},c=c+a_{j},d=d+b_{j}{\text{ (mod }}n)} . עבור i = 1 {\displaystyle i=1} עד 2 מבצעים: j = H ( X ″ ) {\displaystyle j=H(X'')} X ′ = X ′ + R j , c = c {\displaystyle X'=X'+R_{j},c=c} X ″ = X ″ + R j , e = e + a j , f = f + b j  (mod  n ) {\displaystyle X''=X''+R_{j},e=e+a_{j},f=f+b_{j}{\text{ (mod }}n)} . עד שמתקבל X ′ = X ″ {\displaystyle X'=X''} . אם d = f {\displaystyle d=f} האלגוריתם הסתיים בכישלון, אחרת מחזירים את l = ( c − e ) ( f − d ) − 1  mod  n {\displaystyle l=(c-e)(f-d)^{-1}{\text{ mod }}n} . נתון העקום E ( F 229 ) {\displaystyle E(\mathbb {F} _{229})} עם המשוואה E : y 2 = x 3 + x + 44 {\displaystyle E:y^{2}=x^{3}+x+44} . נקודה P = ( x , y ) = ( 5 , 116 ) {\displaystyle P=(x,y)=(5,116)} היא מסדר ראשוני n = 239 {\displaystyle n=239} . תהי הנקודה Q = ( 155 , 166 ) ∈ ⟨ P ⟩ {\displaystyle Q=(155,166)\in \langle P\rangle } . כדי למצוא את l = log P ⁡ Q {\displaystyle l=\log _{P}Q} מגדירים תחילה L = 4 {\displaystyle L=4} ובוחרים פונקציית חלוקה H : ⟨ P ⟩ → { 1 , 2 , 3 , 4 } {\displaystyle H:\langle P\rangle \rightarrow \{1,2,3,4\}} לפי הכלל: H ( x , y ) = ( x  mod  4 ) + 1 {\displaystyle H(x,y)=(x{\text{ mod }}4)+1} בוחרים ומחשבים ארבע שלשות: [ a 1 , b 1 , R 1 ] = [ 79 , 163 , ( 135 , 117 ) ] {\displaystyle [a_{1},b_{1},R_{1}]=[79,163,(135,117)]} [ a 2 , b 2 , R 2 ] = [ 206 , 19 , ( 96 , 97 ) ] {\displaystyle [a_{2},b_{2},R_{2}]=[206,19,(96,97)]} [ a 3 , b 3 , R 3 ] = [ 87 , 109 , ( 84 , 62 ) ] {\displaystyle [a_{3},b_{3},R_{3}]=[87,109,(84,62)]} [ a 4 , b 4 , R 4 ] = [ 219 , 68 , ( 72 , 134 ) ] {\displaystyle [a_{4},b_{4},R_{4}]=[219,68,(72,134)]} הטבלה הבאה מציגה את השלשות ( c , d , X ′ {\displaystyle c,d,X'} ) ו-( e , f , X ″ {\displaystyle e,f,X''} ) המתקבלות לאחר הצעד הרביעי באלגוריתם עבור המקרה ( c , d ) = ( 54 , 175 ) {\displaystyle (c,d)=(54,175)} . אפשר לראות בשורה האחרונה בטבלה שהאלגוריתם מצא התנגשות כי: 192 P + 24 Q = 213 P + 104 Q {\displaystyle 192P+24Q=213P+104Q} לכן l = ( 192 − 213 ) ⋅ ( 104 − 24 ) − 1  mod  239 = 176 {\displaystyle l=(192-213)\cdot (104-24)^{-1}{\text{ mod }}239=176} . בגלל הפופולריות של עקומים אליפטיים בקריפטוגרפיה, נעשה מאמץ לשפר את אלגוריתם רו של פולרד בין היתר על ידי עיבוד מקבילי. נניח שזמינים M {\displaystyle M} מחשבים לצורך פתרון הבעיה. הדרך הנאיבית היא להריץ את האלגוריתם על כל מחשב בנפרד עם נקודות התחלה אקראיות שונות, עד שאחד מהם יגלה התנגשות. שיטה זו אינה מנצלת את פוטנציאל המקביליות כי השיפור בביצועים הוא בפקטור M {\displaystyle {\sqrt {M}}} לכל היותר. פול ואן-אורשוט ומייקל ויינר הציעו גרסה מקבילית של אלגוריתם רו שמניבה שיפור בביצועים בפקטור של M {\displaystyle M} . הרעיון הוא לאפשר לכל הסדרות { X i } i ≥ 0 {\displaystyle \{X_{i}\}_{i\geq 0}} של כל המעבדים להתנגש אחת עם השנייה. ביתר פירוט, כל מעבד בוחר לעצמו נקודת התחלה X 0 {\displaystyle X_{0}} באופן אקראי בנפרד מהאחרים, אולם כל המעבדים משתמשים באותה פונקציה איטרטיבית כדי לחשב את האלמנט הבא בסדרה X i + 1 {\displaystyle X_{i+1}} . לכן, אם נוצרת התנגשות בין שתי סדרות, כל הנקודות של שתי הסדרות החל בנקודה שבה הופיעה התנגשות תהיינה זהות. כדי להתאים את אלגוריתם פלויד למציאת מחזוריות בין סדרות נפרדות שנוצרות על ידי מעבדים שונים, נוקטים באסטרטגיה הבאה, בוחרים מאפיין ייחודי קל לזיהוי המשמש כ"נקודה מובחנת" (Distinguished Point). נקודה מובחנת יכולה להיות כזו המכילה למשל רצף של t {\displaystyle t} אפסים מובילים בקואורדינטה x {\displaystyle x} שלה. בכל פעם שמעבד נתקל בנקודה מובחנת כזו הוא משדר את הנקודה לשרת מרכזי שאוסף את כל הנקודות המובחנות מכל המעבדים וממיין אותם בזיכרון. אם השרת מקבל בשלב כלשהו נקודה מובחנת שכבר התקבלה קודם לכן, הוא מחשב את הלוגריתם הבדיד ומסיים בהצלחה. אם הפרופורציה של הנקודות המובחנות ב- ⟨ P ⟩ {\displaystyle \langle P\rangle } היא θ {\displaystyle \theta } הסיכויים לקבל התנגשות הם בערך 1 / θ {\displaystyle 1/\theta } לכן מספר פעולות כפל נקודות בעקום הצפוי מכל מעבד עד שמתקבלת התנגשות אחת הוא 1 M π n 2 + 1 θ {\displaystyle {\frac {1}{M}}{\sqrt {\frac {\pi n}{2}}}+{\frac {1}{\theta }}} . בכך מושגת האצה ליניארית במהירות הביצוע של האלגוריתם ביחס למספר המעבדים הזמינים. ההתקשרות עם השרת המרכזי היא מינימלית וכן אין צורך בתקשורת כלשהי של המחשבים בינם לבין עצמם מלבד עם השרת. אפשר לשלוט בכמות הזיכרון הנדרשת בשרת המרכזי על ידי בחירה נכונה של תכונת ההבחנה באופן כזה שמצד אחד לא תהיה נדירה ויהיה קשה למצוא נקודה כזו אך מצד שני שלא תהיה תדירה מדי ואז כמות הזיכרון עלולה להיות מופרזת. דרך נוספת לשפר ביצועים היא על ידי שימוש באוטומורפיזם. יהי ψ : ⟨ P ⟩ → ⟨ P ⟩ {\displaystyle \psi :\langle P\rangle \rightarrow \langle P\rangle } אוטומורפיזם של חבורה, כאשר P {\displaystyle P} היא נקודה בעקום מסדר n {\displaystyle n} . בהנחה שקל לחשב את ψ {\displaystyle \psi } והיא מסדר t {\displaystyle t} . כלומר t {\displaystyle t} הוא השלם הקטן ביותר כך ש- ψ t ( R ) = R {\displaystyle \psi ^{t}(R)=R} עבור כל R {\displaystyle R} ב- ⟨ P ⟩ {\displaystyle \langle P\rangle } . מגדירים יחס שקילות על ⟨ P ⟩ {\displaystyle \langle P\rangle } המסומן ∼ {\displaystyle \sim } על ידי R 1 ∼ R 2 {\displaystyle R_{1}\sim R_{2}} אם ורק אם R 1 = ψ j ( R 2 ) {\displaystyle R_{1}=\psi ^{j}(R_{2})} עבור j {\displaystyle j} בטווח [ 0 , t − 1 ] {\displaystyle [0,t-1]} . מחלקת השקילות [R] היא [ R ] = { R , ψ ( R ) , ψ 2 ( R ) , . . . , ψ l − 1 ( R ) } {\displaystyle [R]=\{R,\psi (R),\psi ^{2}(R),...,\psi ^{l-1}(R)\}} כאשר l {\displaystyle l} הוא המחלק הקטן ביותר של t {\displaystyle t} המקיים ψ l ( R ) = R {\displaystyle \psi ^{l}(R)=R} . הרעיון בהאצת האלגוריתם הוא לשנות את פונקציית האיטרציה f {\displaystyle f} שתהיה מעל מחלקת השקילות [ R ] {\displaystyle [R]} . כדי לעשות זאת מגדירים הצגה קנונית של R ¯ {\displaystyle {\overline {R}}} של כל מחלקת שקילות [ R ] {\displaystyle [R]} . למשל R ¯ {\displaystyle {\overline {R}}} יכולה להיות הנקודה ב- [ R ] {\displaystyle [R]} שהקואורדינטה x {\displaystyle x} שלה היא השלם הקטן ביותר. או למשל העתקת השלילה ψ ( P ) = − P {\displaystyle \psi (P)=-P} . שאז אפשר להגדיר את פונקציית האיטרציה g {\displaystyle g} על ידי g ( R ) = f ( R ) ¯ {\displaystyle g(R)={\overline {f(R)}}} . אם נניח שקיים שלם λ {\displaystyle \lambda } המקיים ψ ( P ) = λ P {\displaystyle \psi (P)=\lambda P} אז, היות ש- ψ {\displaystyle \psi } היא אוטומורפית מתקבל ψ ( R ) = λ R {\displaystyle \psi (R)=\lambda R} עבור כל R ∈ ⟨ P ⟩ {\displaystyle R\in \langle P\rangle } . אם מוצאים שני שלמים a , b {\displaystyle a,b} המקיימים X = a P + b Q {\displaystyle X=aP+bQ} אז אפשר לחשב בקלות את השלמים a ′ , b ′ {\displaystyle a',b'} המקיימים X ¯ = a ′ P + b ′ Q {\displaystyle {\overline {X}}=a'P+b'Q} . אם X ¯ = ψ j ( X ) {\displaystyle {\overline {X}}=\psi ^{j}(X)} אז a ′ = λ j a  mod  n {\displaystyle a'=\lambda ^{j}a{\text{ mod }}n} וכן b ′ = λ j b  mod  n {\displaystyle b'=\lambda ^{j}b{\text{ mod }}n} . הפונקציה g {\displaystyle g} כאן משמשת כפונקציה איטרטיבית באלגוריתם רו בגרסה המקבילית שלו עם M {\displaystyle M} מעבדים. הנקודה התחלתית של כל סדרה היא X 0 ′ = X 0 ¯ {\displaystyle X_{0}'={\overline {X_{0}}}} כאשר X 0 = a 0 P + b 0 Q {\displaystyle X_{0}=a_{0}P+b_{0}Q} ו- a 0 , b 0 {\displaystyle a_{0},b_{0}} הם שלמים אקראיים הנמוכים מ- n {\displaystyle n} . הנקודות הבאות בכל סדרה מחושבות על ידי X i ′ = g ( X i − 1 ′ ) {\displaystyle X_{i}'=g(X_{i-1}')} . אם רוב מחלקות השקילות של ⟨ P ⟩ {\displaystyle \langle P\rangle } הן באורך t {\displaystyle t} אז טווח החיפוש מצטמצם ל- n / t {\displaystyle n/t} ולכן זמן הרצוי המשוער של האלגוריתם בגרסה משופרת זו הוא 1 M π n 2 t + 1 θ {\displaystyle {\frac {1}{M}}{\sqrt {\frac {\pi n}{2t}}}+{\frac {1}{\theta }}} . זהו שיפור בפקטור של t {\displaystyle {\sqrt {t}}} במהירות הביצוע. אם משתמשים בהעתקת השלילה ψ ( P ) = − P {\displaystyle \psi (P)=-P} כאוטומורפיזם, מושג שיפור בפקטור של 2 {\displaystyle {\sqrt {2}}} . במקרה של עקום קובליץ E a {\displaystyle E_{a}} מעל F 2 {\displaystyle \mathbb {F} _{2}} שהוא עקום פופולרי בתקנים של NIST וסרטיקום, העתקת פרובניוס τ : E a ( F 2 m ) → E a ( F 2 m ) {\displaystyle \tau :E_{a}(\mathbb {F} _{2^{m}})\rightarrow E_{a}(\mathbb {F} _{2^{m}})} המוגדרת על ידי τ ( O ) = O {\displaystyle \tau ({\mathcal {O}})={\mathcal {O}}} וכן τ ( x , y ) = ( x 2 , y 2 ) {\displaystyle \tau (x,y)=(x^{2},y^{2})} גם היא אוטומורפיזם של חבורה מסדר m {\displaystyle m} והיא קלה לחישוב היות שהעלאה בריבוע היא פעולה קלה בשדה הבינארי (בהצגה פולינומית העלאה בריבוע מודולו 2 שקולה למעשה להכנסת אפסים בין כל הספרות לסירוגין). אם P ∈ E a {\displaystyle P\in E_{a}} הוא מסדר ראשוני n {\displaystyle n} כך ש- n 2 {\displaystyle n^{2}} אינו מחלק של סדר העקום המסומן ב- # E a {\displaystyle \#E_{a}} אז τ ( P ) ∈ ⟨ P ⟩ {\displaystyle \tau (P)\in \langle P\rangle } ולכן τ {\displaystyle \tau } היא אוטומורפית. יהי μ = ( − 1 ) 1 − a {\displaystyle \mu =(-1)^{1-a}} אפשר להוכיח שאחד מהפתרונות λ {\displaystyle \lambda } של המשוואה המודולרית λ 2 − μ λ + 2 ≡ 0  (mod  n ) {\displaystyle \lambda ^{2}-\mu \lambda +2\equiv 0{\text{ (mod }}n)} מקיים τ ( P ) = λ P {\displaystyle \tau (P)=\lambda P} . לכן באופן דומה, הגרסה המקבילית של אלגוריתם רו עם M {\displaystyle M} מעבדים המשתמשת במחלקות השקילות תחת העתקת פרובניוסמגיעה לזמן ריצה של 1 M π n 2 m + 1 θ {\displaystyle {\frac {1}{M}}{\sqrt {\frac {\pi n}{2m}}}+{\frac {1}{\theta }}} . ואם מנצלים גם את העתקת השלילה מושג שיפור כולל בזמן הריצה בפקטור של 2 m {\displaystyle {\sqrt {2m}}} . למשל ההערכה המקורית שניתנה ב-1996 הייתה שכדי לפתור את בעיית הלוגריתם הבדיד בעקום אליפטי מסדר 113 בהנחה שזמינים 10,000 מעבדים לצורך המשימה כשכל אחד מהם מסוגל לבצע איטרציה אחת בעשר מילישניות, אם θ = 2 − 30 {\displaystyle \theta =2^{-30}} אז מספר החזרות הצפוי בכל מעבד לפני שמוצאים לוגריתם הוא π 2 113 2 ⋅ 10000 + 2 30 ≈ 9.03 × 10 13 {\displaystyle {\frac {\sqrt {\pi 2^{113}}}{2\cdot 10000}}+2^{30}\approx 9.03\times 10^{13}} . שזה שקול בערך ל-1045 ימים או שלוש שנות עיבוד עם כמות של כארבע גיגה-בית זיכרון. הערכות יותר מעודכנות קצת יותר אופטימיות. לדוגמה ב-2002 הצליח צוות חוקרים בראשות קריס מוניקו לפצח את העקום האליפטי ECCp-109 עם 10,000 מחשבים שעבדו במקביל בסך הכול 549 ימים. הם השתמשו בגרסה משופרת של אלגוריתם רו של פולרד והצליחו לפתור את בעיית דיפי-הלמן בעקום זה. Hankerson, Darrel, Menezes, Alfred J., Vanstone, Scott (2004) Guide to Elliptic Curve Cryptography Pollard, J. M. (1978). Monte Carlo methods for index computation (mod p). "Mathematics of Computation" . 32 (143): 918–924 Brent, Richard P. (1980), "An Improved Monte Carlo Factorization Algorithm", BIT, 20: 176–184 Menezes, Alfred J.; van Oorschot, Paul C.; Vanstone, Scott A. (2001). "Chapter 3 - Number-Theoretic Reference Problems" (PDF). "Handbook of Applied Cryptography". Paul C. van Oorschot, Michael J. Wiener, "Parallel Collision Search with Cryptanalytic Applications" Journal of Cryptology January 1999, Volume 12, Issue 1, pp 1–28