File size: 7,417 Bytes
5d5048e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 | 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--mask keys may contain many keys with the same weight; linearity
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δ
/-- Weighted finite Markov for any nonnegative counted quantity. -/
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
/-- Concrete extra-prime bucket success. The equal-weight capacity premise
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
|