File size: 2,688 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 | 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
|