Das Generalized Birthday Problem Problem

Das Generalized Birthday Problem

Problem Birthday

Gegeben: Listen L₁,L₂ mit Elementen ausFⁿ₂ Gesucht: x₁∈L₁und x₂∈L₂mit x₁+x₂=0 inFⁿ₂

Anwendungen:

Meet-in-the-Middle Angriffe (z.B. für RSA, ElGamal) Kennen Lösung für|L₁|=|L₂|=2ⁿ² in ZeitO(2˜ ⁿ²).

Problem Generalized Birthday

Gegeben: Listen L₁, . . . ,L_k mit Elementen ausFⁿ₂, unabhängig und gleichverteilt gezogen

Gesucht: x₁∈L₁, . . . ,x_k ∈L_k mit x₁+. . .+x_k =0 inFⁿ₂

Listen können auf beliebige Länge erweitert werden.

Wir erwarten die Existenz einer Lösung sobald|L₁| ·. . .· |L_k|>2ⁿ.

Zusammenfügen zweier Listen

Definition Join-Operator

Wir bezeichnen mitlowℓ(x)dieℓniederwertigsten Bits von x . Wir definieren für zwei Listen L₁,L₂den Join-Operator

L₁⊲⊳ℓ L₂={(x1,x₂,x₁+x₂)∈L₁×L₂×Fⁿ2|lowℓ(x1) =lowℓ(x2)}.

Eigenschaften:

Es giltlow_ℓ(x₁+x₂) =0 gdwlow_ℓ(x₁) =low_ℓ(x₂).

Bei Eingabe L₁,L₂kann L₁⊲⊳L₂berechnet werden in Zeit O(max{|L˜ 1|,|L2|,|L1|⊲⊳ℓ |L2|}).

Es gilt x₁+x₂=x₃+x₄gdw x₁+x₂+x₃+x₄=0.

Fallslowℓ(x1+x₂) =0 undlowℓ(x3+x₄) =0, dann gilt low (x +x +x +x ) =0 und

Algorithmus für das 4-Listen Problem

Algorithmus 4-Listen Problem

EINGABE: L₁,L₂,L₃,L₄der Länge|L_i|=2ⁿ³ mit Elementen ausFⁿ₂

1 Setzeℓ:= ⁿ₃.

2 Berechne L₁₂=L₁⊲⊳_ℓ L₂und L₃₄=L₃⊲⊳_ℓ L₄.

3 Berechne L₁₂₃₄=L₁₂ ⊲⊳nL₃₄. AUSGABE: Elemente von L₁₂₃₄

Korrektheit des 4-Listen Problem Algorithmus

Korrektheit:

Elemente von L₁₂,L₃₄erfüllenlowⁿ

3(x1+x₂) =lowⁿ

3(x3+x₄) =0.

Wir erwarten Listenlänge E[|L₁₂|] =P

(x1,x2)∈L1×L2Ws[lowⁿ

3(x₁+x₂) =0] = ^|L1|·|L2|

2ⁿ³ =2ⁿ³. Analog gilt E[|L₃₄|] =2ⁿ³.

Elemente von L₁₂₃₄erfüllen x₁+x₂+x₃+x₄=0.

Die erwartete Listenlänge E[|L₁₂₃₄|]von L₁₂₃₄ist P

(x1,...,x4)∈L12×L34Ws[x1+. . .+x4=0|lowⁿ

3(x1+x2) =lowⁿ

3(x3+x4)]

= ^{E(|L12|)·E(|L34|)}

2²ⁿ³ =1.

D.h. wir erwarten, dass L₁₂₃₄eine Lösung enthält.

Laufzeitanalyse des 4-Listen Problem Algorithmus

Laufzeit und Speicherplatz:

Die Listen L₁, . . . ,L₄,L₁₂,L₃₄ benötigen jeweils PlatzO(2˜ ⁿ³).

Die Konstruktion von L₁₂,L₃₄ geht in LaufzeitO(2˜ ⁿ³).

Konstruktion von L₁₂₃₄benötigt ebenfalls LaufzeitO(2˜ ⁿ³).

Gesamt: Zeit und PlatzO(2˜ ⁿ³)

Übungen: Modifizieren Sie den Algorithmus, so dass lowℓ(x1+x₂) =lowℓ(x3+x₄) =c für ein c∈F^ℓ₂. wir x₁+x₂+x₃+x₄=c^′ für ein c^′ ∈Fⁿ₂lösen können.

wir jede Instanz mit k ≥4 in Zeit und PlatzO(2˜ ⁿ³)lösen können.

4-Listen Problem in Z

Ziel: Verwende Gruppe(Z2ⁿ,+)statt(F2ⁿ,+).

Sei−L={−x ∈Z2ⁿ |x ∈L}.

Algorithmus 4-Listen Problem

EINGABE: L₁,L₂,L₃,L₄mit Elementen ausZ2ⁿ der Länge|L_i|=2ⁿ³

1 Setzeℓ:= ⁿ₃.

2 Berechne L₁₂=L₁⊲⊳_ℓ −L2und L₃₄=L₃⊲⊳_ℓ −L4.

3 Berechne L₁₂₃₄=L₁₂ ⊲⊳_n−L₃₄. AUSGABE: Elemente von L₁₂₃₄

Korrektheit:

Wir erhalten(x₁,x₂,x₁+x₂)∈L₁₂mit x₁+x₂=0mod2^ℓ.

Algorithmus k -Listen Problem, k = 2

Algorithmus k-Listen Problem

EINGABE: L₁, . . . ,L₂^m mit Elementen ausFⁿ₂, Länge|L_i|=2^m+1n

1 Setzeℓ:= _m+1ⁿ .

2 For i :=1 to m−1

1 FOR j:=1 to 2^mstep 2ⁱ

/* Join aller benachbarten Listen auf Level i des Baumes */

2 Berechne L_j...j+2i−1=L_j...j+2i−1−1⊲⊳_iℓL_j+2i−1...j+2ⁱ−1.

3 Berechne L_1...2^m =L_1...2m−1 ⊲⊳_n L₂m−1+1...2^m. AUSGABE: Elemente von L_1...2^m

Beispiel für k =2³:

Join für i =1: L₁₂ =L₁⊲⊳_ℓL₂, L₃₄ =L₃⊲⊳_ℓL₄, . . . , L₇₈=L7⊲⊳_ℓ L₈. Join für i =2: L₁₂₃₄=L₁₂⊲⊳_ℓL₃₄, L₅₆₇₈=L₅₆ ⊲⊳_ℓ L₇₈.

Join in Schritt 3: L_1...8=L_1...4⊲⊳nL_5...8.

Analyse des k -Listen Algorithmus

Korrektheit:

Alle Startlisten besitzen Länge 2^ℓ.

D.h. durch das Join auf unterster Ebene entstehen Listen mit erwarteter Länge ^2ℓ₂^·ℓ^2ℓ =2^ℓ.

Damit entstehen in Schritt 2 stets Listen mit erwarteter Länge 2^ℓ. In Schritt 3 entsteht eine Liste L_1...k mit erwarteter Länge

P

(x1,...,xk)Ws[x₁+. . .+x_k =0|low_(m−1)ℓ(x₁+. . .+xk 2

) = low_(m−1)ℓ(xk

2+1+. . .+x_k)] = ₂n−(m^22ℓ−1)ℓ =1.

Analyse des k -Listen Algorithmus

Laufzeit und Platz:

Die Listen L₁, . . . ,L_k benötigen jeweils PlatzO(2˜ ^ℓ).

In Schritt 2 berechnen wir k−2 Listen mit erwarteter LängeO(2˜ ^ℓ).

Damit erhalten wir SpeicherplatzbedarfO(k 2˜ ^ℓ) = ˜O(k 2^{log kn+1}).

Die Laufzeit für alle k−1 Join-Operationen beträgtO(2˜ ^ℓ).

Damit ist die Gesamtlaufzeit ebenfallsO(k 2˜ ^ℓ) = ˜O(k 2^{log k+1n} ) Für k =2^√nerhalten wir Zeit und Speicherplatz Komplexität

O(2˜ ^√n·2

n

√n+1) = ˜O(2^2√n).

Dies ist eine subexponentielle Funktion in n.

Übung: Konstruieren Sie einen Algorithmus für k =2^m+j,0<j <2^m mit KomplexitätO(k 2˜ ^{log kn+1}).

Offenes Problem:

Geht es für k =2^m+j besser? Für k=3 besser alsO(2˜ ⁿ²)?