| import OAI.Combinatorics.LowSpaceSubsetSum.Counting.PrimeHashCollision |
|
|
| namespace OAI |
|
|
| /-! |
| # Overflow probability for one fixed solution bucket |
|
|
| Equal actual weights are separated before prime collision estimates. A finite |
| set of weight |
| of expectation counts every such key when its weight differs from the fixed |
| solution's weight. This is the bucket argument in both trial analyses. |
| -/ |
|
|
| namespace LowSpaceSubsetSum |
|
|
| open scoped BigOperators |
|
|
| variable {Ω α β : Type*} [DecidableEq β] |
|
|
| def sameWeightKeys (X : Finset α) (value : α → ℤ) (x : α) : Finset α := |
| X.filter fun y => value y = value x |
|
|
| def otherCollisionKeys (X : Finset α) (value : α → ℤ) (hash : ℤ → β) |
| (x : α) : Finset α := |
| (X.filter fun y => value y ≠ value x).filter fun y => hash (value y) = hash (value x) |
|
|
| def hashBucket (X : Finset α) (value : α → ℤ) (hash : ℤ → β) (x : α) : Finset α := |
| X.filter fun y => hash (value y) = hash (value x) |
|
|
| theorem hashBucket_card (X : Finset α) (value : α → ℤ) (hash : ℤ → β) (x : α) : |
| (hashBucket X value hash x).card = |
| (sameWeightKeys X value x).card + (otherCollisionKeys X value hash x).card := by |
| classical |
| have heq : hashBucket X value hash x = |
| sameWeightKeys X value x ∪ otherCollisionKeys X value hash x := by |
| ext y |
| by_cases h : value y = value x <;> |
| simp [hashBucket, sameWeightKeys, otherCollisionKeys, h] |
| rw [heq, Finset.card_union_of_disjoint] |
| apply Finset.disjoint_left.mpr |
| intro y hy hz |
| exact (Finset.mem_filter.mp (Finset.mem_filter.mp hz).1).2 (Finset.mem_filter.mp hy).2 |
|
|
| theorem expected_otherCollisionKeys_le (seeds : Finset Ω) (prob : Ω → ℝ) |
| (X : Finset α) (value : α → ℤ) (hash : Ω → ℤ → β) {x : α} (hx : x ∈ X) |
| {δ : ℝ} (hδ : 0 ≤ δ) |
| (hcollision : PairwiseCollisionBound seeds prob (X.image value) hash δ) : |
| (∑ ω ∈ seeds, prob ω * (otherCollisionKeys X value (hash ω) x).card) ≤ |
| δ * X.card := by |
| classical |
| let others := X.filter fun y => value y ≠ value x |
| have hcard (ω : Ω) : ((otherCollisionKeys X value (hash ω) x).card : ℝ) = |
| ∑ y ∈ others, if hash ω (value y) = hash ω (value x) then (1 : ℝ) else 0 := by |
| simp [others, otherCollisionKeys] |
| simp_rw [hcard, Finset.mul_sum] |
| rw [Finset.sum_comm] |
| calc |
| _ ≤ ∑ _y ∈ others, δ := by |
| apply Finset.sum_le_sum |
| intro y hy |
| obtain ⟨hyX, hyne⟩ := Finset.mem_filter.mp hy |
| exact hcollision (value y) (Finset.mem_image.mpr ⟨y, hyX, rfl⟩) |
| (value x) (Finset.mem_image.mpr ⟨x, hx, rfl⟩) hyne |
| _ ≤ δ * X.card := by |
| have hcard : (others.card : ℝ) ≤ X.card := by |
| exact_mod_cast Finset.card_filter_le (s := X) (p := fun y => value y ≠ value x) |
| simpa only [Finset.sum_const, nsmul_eq_mul, mul_comm] using |
| mul_le_mul_of_nonneg_left hcard hδ |
|
|
| / |
| theorem probability_count_le (seeds : Finset Ω) (prob : Ω → ℝ) (count : Ω → ℕ) |
| (hnonneg : ∀ ω ∈ seeds, 0 ≤ prob ω) (hprob : ∑ ω ∈ seeds, prob ω = 1) |
| {M T : ℝ} (hT : 0 < T) |
| (hmean : (∑ ω ∈ seeds, prob ω * count ω) ≤ M) : |
| 1 - M / T ≤ ∑ ω ∈ seeds.filter (fun ω => (count ω : ℝ) ≤ T), prob ω := by |
| classical |
| let bad := seeds.filter fun ω => T < (count ω : ℝ) |
| have hbad : T * (∑ ω ∈ bad, prob ω) ≤ M := by |
| calc |
| _ = ∑ ω ∈ bad, prob ω * T := by rw [Finset.mul_sum]; simp [mul_comm] |
| _ ≤ ∑ ω ∈ bad, prob ω * count ω := by |
| apply Finset.sum_le_sum |
| intro ω hω |
| have hm := Finset.mem_filter.mp hω |
| exact mul_le_mul_of_nonneg_left hm.2.le (hnonneg ω hm.1) |
| _ ≤ ∑ ω ∈ seeds, prob ω * count ω := by |
| apply Finset.sum_le_sum_of_subset_of_nonneg (Finset.filter_subset _ _) |
| intro ω hω _ |
| exact mul_nonneg (hnonneg ω hω) (Nat.cast_nonneg _) |
| _ ≤ M := hmean |
| have hbad' : (∑ ω ∈ bad, prob ω) ≤ M / T := by |
| apply (le_div_iff₀ hT).mpr |
| simpa only [mul_comm] using hbad |
| have hpart : (∑ ω ∈ seeds.filter (fun ω => (count ω : ℝ) ≤ T), prob ω) + |
| (∑ ω ∈ bad, prob ω) = 1 := by |
| simp only [bad, Finset.sum_filter] |
| rw [← Finset.sum_add_distrib] |
| convert hprob using 1 |
| apply Finset.sum_congr rfl |
| intro ω _ |
| by_cases hω : (count ω : ℝ) ≤ T |
| · simp [hω, not_lt_of_ge hω] |
| · simp [hω, lt_of_not_ge hω] |
| linarith |
|
|
| theorem fixed_bucket_fits_probability (seeds : Finset Ω) (prob : Ω → ℝ) |
| (X : Finset α) (value : α → ℤ) (hash : Ω → ℤ → β) {x : α} (hx : x ∈ X) |
| (hnonneg : ∀ ω ∈ seeds, 0 ≤ prob ω) (hprob : ∑ ω ∈ seeds, prob ω = 1) |
| {C : ℕ} (hC : 0 < C) (hequal : ((sameWeightKeys X value x).card : ℝ) ≤ (C : ℝ) / 2) |
| {δ : ℝ} (hδ : 0 ≤ δ) |
| (hcollision : PairwiseCollisionBound seeds prob (X.image value) hash δ) : |
| 1 - 2 * δ * X.card / C ≤ |
| ∑ ω ∈ seeds.filter (fun ω => (hashBucket X value (hash ω) x).card ≤ C), prob ω := by |
| classical |
| have hCR : (0 : ℝ) < C := by exact_mod_cast hC |
| have hmean := expected_otherCollisionKeys_le seeds prob X value hash hx hδ hcollision |
| have hmarkov := probability_count_le seeds prob |
| (fun ω => (otherCollisionKeys X value (hash ω) x).card) hnonneg hprob |
| (by positivity : (0 : ℝ) < (C : ℝ) / 2) hmean |
| have hrewrite : (δ * X.card) / ((C : ℝ) / 2) = 2 * δ * X.card / C := by ring |
| rw [hrewrite] at hmarkov |
| apply hmarkov.trans |
| apply Finset.sum_le_sum_of_subset_of_nonneg |
| · intro ω hω |
| obtain ⟨hmem, hother⟩ := Finset.mem_filter.mp hω |
| apply Finset.mem_filter.mpr |
| refine ⟨hmem, ?_⟩ |
| rw [hashBucket_card] |
| have hsum : ((sameWeightKeys X value x).card : ℝ) + |
| (otherCollisionKeys X value (hash ω) x).card ≤ C := by linarith |
| exact_mod_cast hsum |
| · intro ω hω _ |
| exact hnonneg ω (Finset.mem_filter.mp hω).1 |
|
|
| / |
| is supplied separately by the mask-counting lemmas in `Buckets`. -/ |
| theorem prime_fixed_bucket_fits_probability (X : Finset α) (value : α → ℤ) |
| {x : α} (hx : x ∈ X) {ell u C : ℕ} (hell : 4 ≤ ell) (hellu : ell ≤ u) |
| (hC : 0 < C) (hequal : ((sameWeightKeys X value x).card : ℝ) ≤ (C : ℝ) / 2) |
| (hbits : ∀ y ∈ X, ∀ z ∈ X, (value y - value z).natAbs < 2 ^ (2 * u)) : |
| 1 - 16 * (u : ℝ) ^ 2 * X.card / ((C : ℝ) * (2 : ℝ) ^ ell) ≤ |
| ∑ p ∈ (primeRange ell).filter |
| (fun (p : ℕ) => (hashBucket X value (fun w => w % (p : ℤ)) x).card ≤ C), |
| primeProbability ell p := by |
| have hcollision := prime_pairwise_collision_bound (X.image value) hell hellu (by |
| intro y hy z hz |
| obtain ⟨y', hy', rfl⟩ := Finset.mem_image.mp hy |
| obtain ⟨z', hz', rfl⟩ := Finset.mem_image.mp hz |
| exact hbits y' hy' z' hz') |
| have h := fixed_bucket_fits_probability (primeRange ell) (primeProbability ell) |
| X value (fun (p : ℕ) w => w % (p : ℤ)) hx |
| (by intro p _; exact div_nonneg zero_le_one (Nat.cast_nonneg _)) |
| (primeProbability_sum hell) hC hequal |
| (δ := 8 * (u : ℝ) ^ 2 / (2 : ℝ) ^ ell) (by positivity) hcollision |
| convert h using 1 |
| ring |
|
|
| end LowSpaceSubsetSum |
|
|
| end OAI |
|
|
