| import Mathlib.Data.Finset.Prod |
| import Mathlib.Tactic |
|
|
| namespace OAI |
|
|
| /-! |
| # Independent product-modulus collisions |
|
|
| Sample identities, rather than distinct numerical products, form the finite |
| probability space. The factors are allowed to repeat. Product divisibility |
| implies each factor divides the difference, which is all the upper bound needs. |
| -/ |
|
|
| namespace LowSpaceSubsetSum |
|
|
| variable {α β : Type*} |
|
|
| theorem product_divisor_count_le (A : Finset α) (B : Finset β) |
| (f : α → ℕ) (g : β → ℕ) (d : ℕ) : |
| ((A ×ˢ B).filter fun z => f z.1 * g z.2 ∣ d).card ≤ |
| (A.filter fun a => f a ∣ d).card * (B.filter fun b => g b ∣ d).card := by |
| calc |
| _ ≤ ((A.filter fun a => f a ∣ d) ×ˢ (B.filter fun b => g b ∣ d)).card := by |
| apply Finset.card_le_card |
| intro z hz |
| obtain ⟨hzAB, hzd⟩ := Finset.mem_filter.mp hz |
| obtain ⟨hza, hzb⟩ := Finset.mem_product.mp hzAB |
| apply Finset.mem_product.mpr |
| constructor |
| · exact Finset.mem_filter.mpr ⟨hza, dvd_trans (dvd_mul_right _ _) hzd⟩ |
| · exact Finset.mem_filter.mpr ⟨hzb, dvd_trans (dvd_mul_left _ _) hzd⟩ |
| _ = _ := Finset.card_product _ _ |
|
|
| /-- Independent uniform sampling multiplies the individual collision bounds. |
| No coprimality or distinctness of the sampled factors is assumed. -/ |
| theorem product_divisor_probability_le (A : Finset α) (B : Finset β) |
| (f : α → ℕ) (g : β → ℕ) (d : ℕ) (hA : A.Nonempty) (hB : B.Nonempty) |
| {deltaA deltaB : ℝ} (hdeltaA : 0 ≤ deltaA) |
| (ha : ((A.filter fun a => f a ∣ d).card : ℝ) / A.card ≤ deltaA) |
| (hb : ((B.filter fun b => g b ∣ d).card : ℝ) / B.card ≤ deltaB) : |
| (((A ×ˢ B).filter fun z => f z.1 * g z.2 ∣ d).card : ℝ) / |
| (A ×ˢ B).card ≤ deltaA * deltaB := by |
| have hA0 : (0 : ℝ) < A.card := by exact_mod_cast hA.card_pos |
| have hB0 : (0 : ℝ) < B.card := by exact_mod_cast hB.card_pos |
| have hcount : (((A ×ˢ B).filter fun z => f z.1 * g z.2 ∣ d).card : ℝ) ≤ |
| ((A.filter fun a => f a ∣ d).card : ℝ) * |
| ((B.filter fun b => g b ∣ d).card : ℝ) := by |
| exact_mod_cast product_divisor_count_le A B f g d |
| rw [Finset.card_product, Nat.cast_mul] |
| calc |
| _ ≤ (((A.filter fun a => f a ∣ d).card : ℝ) * |
| ((B.filter fun b => g b ∣ d).card : ℝ)) / ((A.card : ℝ) * B.card) := |
| div_le_div_of_nonneg_right hcount (mul_pos hA0 hB0).le |
| _ = (((A.filter fun a => f a ∣ d).card : ℝ) / A.card) * |
| (((B.filter fun b => g b ∣ d).card : ℝ) / B.card) := by ring |
| _ ≤ deltaA * deltaB := mul_le_mul ha hb |
| (div_nonneg (Nat.cast_nonneg _) hB0.le) hdeltaA |
|
|
| end LowSpaceSubsetSum |
|
|
| end OAI |
|
|
