| import Mathlib |
|
|
| namespace OAI |
|
|
| namespace MatrixAllFields |
|
|
| open scoped BigOperators Topology Polynomial |
|
|
| noncomputable section |
|
|
| namespace MatrixMultiplication.JointLossCounts |
|
|
| open scoped BigOperators |
|
|
| attribute [local instance] Classical.propDecidable |
|
|
| variable {Ω V I : Type*} |
|
|
| theorem card_filter_exists_le (samples : Finset Ω) (indices : Finset I) |
| (event : I → Ω → Prop) : |
| (samples.filter (fun ω => ∃ i ∈ indices, event i ω)).card ≤ |
| ∑ i ∈ indices, (samples.filter (event i)).card := by |
| classical |
| have heq : samples.filter (fun ω => ∃ i ∈ indices, event i ω) = |
| indices.biUnion (fun i => samples.filter (event i)) := by |
| ext ω |
| simp only [Finset.mem_filter, Finset.mem_biUnion] |
| constructor |
| · rintro ⟨hω, i, hi, he⟩ |
| exact ⟨i, hi, hω, he⟩ |
| · rintro ⟨i, hi, hω, he⟩ |
| exact ⟨hω, i, hi, he⟩ |
| rw [heq] |
| exact Finset.card_biUnion_le |
|
|
| theorem competitor_union_card_mul_le (ownSurvival : Finset Ω) |
| (competitors : Finset I) (collision : I → Ω → Prop) (M : ℕ) |
| (hcollision : ∀ i ∈ competitors, |
| M * (ownSurvival.filter (collision i)).card ≤ ownSurvival.card) : |
| M * (ownSurvival.filter (fun ω => ∃ i ∈ competitors, collision i ω)).card ≤ |
| competitors.card * ownSurvival.card := by |
| classical |
| calc |
| _ ≤ M * ∑ i ∈ competitors, (ownSurvival.filter (collision i)).card := |
| Nat.mul_le_mul_left M (card_filter_exists_le ownSurvival competitors collision) |
| _ = ∑ i ∈ competitors, M * (ownSurvival.filter (collision i)).card := |
| by rw [Finset.mul_sum] |
| _ ≤ ∑ _i ∈ competitors, ownSurvival.card := |
| Finset.sum_le_sum hcollision |
| _ = _ := by simp |
|
|
| def randomLossCount (passing : Finset V) (bad : V → Ω → Prop) (ω : Ω) : ℕ := by |
| classical |
| exact (passing.filter (fun v => bad v ω)).card |
|
|
| def randomLossFraction (full passing : Finset V) (bad : V → Ω → Prop) (ω : Ω) : ℝ := |
| (randomLossCount passing bad ω : ℝ) / (full.card : ℝ) |
|
|
| theorem randomLossFraction_nonneg (full passing : Finset V) |
| (bad : V → Ω → Prop) (ω : Ω) : 0 ≤ randomLossFraction full passing bad ω := |
| div_nonneg (Nat.cast_nonneg _) (Nat.cast_nonneg _) |
|
|
| theorem sum_randomLossCount (ownSurvival : Finset Ω) (passing : Finset V) |
| (bad : V → Ω → Prop) : |
| (∑ ω ∈ ownSurvival, randomLossCount passing bad ω) = |
| ∑ v ∈ passing, (ownSurvival.filter (bad v)).card := by |
| classical |
| simp only [randomLossCount, Finset.card_filter] |
| exact Finset.sum_comm |
|
|
| theorem sum_randomLossCount_le (ownSurvival : Finset Ω) (full passing : Finset V) |
| (bad : V → Ω → Prop) (ε : ℝ) (hε : 0 ≤ ε) (hpassing : passing ⊆ full) |
| (hbad : ∀ v ∈ passing, |
| ((ownSurvival.filter (bad v)).card : ℝ) ≤ ε * (ownSurvival.card : ℝ)) : |
| (∑ ω ∈ ownSurvival, (randomLossCount passing bad ω : ℝ)) ≤ |
| (full.card : ℝ) * (ε * (ownSurvival.card : ℝ)) := by |
| classical |
| have hdouble : (∑ ω ∈ ownSurvival, (randomLossCount passing bad ω : ℝ)) = |
| ∑ v ∈ passing, ((ownSurvival.filter (bad v)).card : ℝ) := by |
| exact_mod_cast sum_randomLossCount ownSurvival passing bad |
| rw [hdouble] |
| calc |
| _ ≤ ∑ _v ∈ passing, ε * (ownSurvival.card : ℝ) := Finset.sum_le_sum hbad |
| _ = (passing.card : ℝ) * (ε * (ownSurvival.card : ℝ)) := by simp |
| _ ≤ _ := mul_le_mul_of_nonneg_right |
| (by exact_mod_cast Finset.card_le_card hpassing) |
| (mul_nonneg hε (Nat.cast_nonneg _)) |
|
|
| theorem sum_randomLossFraction_le (ownSurvival : Finset Ω) (full passing : Finset V) |
| (bad : V → Ω → Prop) (ε : ℝ) (hε : 0 ≤ ε) (hfull : 0 < full.card) |
| (hpassing : passing ⊆ full) |
| (hbad : ∀ v ∈ passing, |
| ((ownSurvival.filter (bad v)).card : ℝ) ≤ ε * (ownSurvival.card : ℝ)) : |
| (∑ ω ∈ ownSurvival, randomLossFraction full passing bad ω) ≤ |
| ε * (ownSurvival.card : ℝ) := by |
| have hcard : (0 : ℝ) < full.card := by exact_mod_cast hfull |
| simp only [randomLossFraction, ← Finset.sum_div] |
| apply (div_le_iff₀ hcard).2 |
| simpa only [mul_comm] using |
| sum_randomLossCount_le ownSurvival full passing bad ε hε hpassing hbad |
|
|
| theorem conditional_mean_randomLossFraction_le |
| (ownSurvival : Finset Ω) (full passing : Finset V) (bad : V → Ω → Prop) |
| (ε : ℝ) (hε : 0 ≤ ε) (hs : 0 < ownSurvival.card) (hfull : 0 < full.card) |
| (hpassing : passing ⊆ full) |
| (hbad : ∀ v ∈ passing, |
| ((ownSurvival.filter (bad v)).card : ℝ) ≤ ε * (ownSurvival.card : ℝ)) : |
| (∑ ω ∈ ownSurvival, randomLossFraction full passing bad ω) / |
| (ownSurvival.card : ℝ) ≤ ε := by |
| apply (div_le_iff₀ (by exact_mod_cast hs : (0 : ℝ) < ownSurvival.card)).2 |
| exact sum_randomLossFraction_le ownSurvival full passing bad ε hε hfull hpassing hbad |
|
|
| theorem card_filter_mul_le_sum (samples : Finset Ω) (f : Ω → ℝ) (t : ℝ) |
| (hf : ∀ ω ∈ samples, 0 ≤ f ω) : |
| ((samples.filter (fun ω => t < f ω)).card : ℝ) * t ≤ |
| ∑ ω ∈ samples, f ω := by |
| classical |
| calc |
| _ = ∑ _ω ∈ samples.filter (fun ω => t < f ω), t := by simp |
| _ ≤ ∑ ω ∈ samples.filter (fun ω => t < f ω), f ω := by |
| apply Finset.sum_le_sum |
| intro ω hω |
| exact (Finset.mem_filter.mp hω).2.le |
| _ ≤ _ := Finset.sum_le_sum_of_subset_of_nonneg (Finset.filter_subset _ _) |
| (fun ω hω _ => hf ω hω) |
|
|
| theorem bad_orbit_card_le (ownSurvival : Finset Ω) (full passing : Finset V) |
| (bad : V → Ω → Prop) (ε N : ℝ) (hε : 0 ≤ ε) (hN : 0 < N) |
| (hfull : 0 < full.card) (hpassing : passing ⊆ full) |
| (hbad : ∀ v ∈ passing, |
| ((ownSurvival.filter (bad v)).card : ℝ) ≤ ε * (ownSurvival.card : ℝ)) : |
| ((ownSurvival.filter (fun ω => 1 / N < randomLossFraction full passing bad ω)).card : ℝ) |
| ≤ N * ε * (ownSurvival.card : ℝ) := by |
| classical |
| have hm := card_filter_mul_le_sum ownSurvival |
| (randomLossFraction full passing bad) (1 / N) |
| (fun ω _ => randomLossFraction_nonneg full passing bad ω) |
| have he := sum_randomLossFraction_le ownSurvival full passing bad ε hε hfull hpassing hbad |
| have hdiv : |
| ((ownSurvival.filter (fun ω => 1 / N < randomLossFraction full passing bad ω)).card : ℝ) / N |
| ≤ ε * (ownSurvival.card : ℝ) := by |
| simpa only [one_div, ← div_eq_mul_inv] using hm.trans he |
| have hmul := (div_le_iff₀ hN).1 hdiv |
| simpa only [mul_assoc, mul_comm, mul_left_comm] using hmul |
| |
| def targetBad (orbits : Finset I) (full passing : I → Finset V) |
| (bad : I → V → Ω → Prop) (eligible : Ω → Prop) (N : ℝ) (ω : Ω) : Prop := |
| ¬ eligible ω ∨ ∃ i ∈ orbits, 1 / N < randomLossFraction (full i) (passing i) (bad i) ω |
| |
| theorem targetBad_card_le (ownSurvival : Finset Ω) (orbits : Finset I) |
| (full passing : I → Finset V) (bad : I → V → Ω → Prop) |
| (eligible : Ω → Prop) (ε eligibilityError N : ℝ) |
| (hε : 0 ≤ ε) (hN : 0 < N) |
| (hfull : ∀ i ∈ orbits, 0 < (full i).card) |
| (hpassing : ∀ i ∈ orbits, passing i ⊆ full i) |
| (hbad : ∀ i ∈ orbits, ∀ v ∈ passing i, |
| ((ownSurvival.filter (bad i v)).card : ℝ) ≤ ε * (ownSurvival.card : ℝ)) |
| (heligible : ((ownSurvival.filter (fun ω => ¬ eligible ω)).card : ℝ) ≤ |
| eligibilityError * (ownSurvival.card : ℝ)) : |
| ((ownSurvival.filter (targetBad orbits full passing bad eligible N)).card : ℝ) ≤ |
| (eligibilityError + (orbits.card : ℝ) * N * ε) * (ownSurvival.card : ℝ) := by |
| classical |
| let excess := fun i ω => 1 / N < randomLossFraction (full i) (passing i) (bad i) ω |
| have hunion : ownSurvival.filter (targetBad orbits full passing bad eligible N) = |
| (ownSurvival.filter (fun ω => ¬ eligible ω)) ∪ |
| (ownSurvival.filter (fun ω => ∃ i ∈ orbits, excess i ω)) := by |
| ext ω |
| simp only [Finset.mem_filter, Finset.mem_union, targetBad, excess] |
| constructor |
| · rintro ⟨hω, he | ho⟩ |
| · exact Or.inl ⟨hω, he⟩ |
| · exact Or.inr ⟨hω, ho⟩ |
| · rintro (⟨hω, he⟩ | ⟨hω, ho⟩) |
| · exact ⟨hω, Or.inl he⟩ |
| · exact ⟨hω, Or.inr ho⟩ |
| have hu : ((ownSurvival.filter (targetBad orbits full passing bad eligible N)).card : ℝ) ≤ |
| ((ownSurvival.filter (fun ω => ¬ eligible ω)).card : ℝ) + |
| ((ownSurvival.filter (fun ω => ∃ i ∈ orbits, excess i ω)).card : ℝ) := by |
| rw [hunion] |
| exact_mod_cast Finset.card_union_le |
| (ownSurvival.filter (fun ω => ¬ eligible ω)) |
| (ownSurvival.filter (fun ω => ∃ i ∈ orbits, excess i ω)) |
| have horbits : ((ownSurvival.filter (fun ω => ∃ i ∈ orbits, excess i ω)).card : ℝ) ≤ |
| ∑ i ∈ orbits, ((ownSurvival.filter (excess i)).card : ℝ) := by |
| exact_mod_cast card_filter_exists_le ownSurvival orbits excess |
| have hsum : (∑ i ∈ orbits, ((ownSurvival.filter (excess i)).card : ℝ)) ≤ |
| (orbits.card : ℝ) * (N * ε * (ownSurvival.card : ℝ)) := by |
| calc |
| _ ≤ ∑ _i ∈ orbits, N * ε * (ownSurvival.card : ℝ) := by |
| apply Finset.sum_le_sum |
| intro i hi |
| exact bad_orbit_card_le ownSurvival (full i) (passing i) (bad i) |
| ε N hε hN (hfull i hi) (hpassing i hi) (hbad i hi) |
| _ = _ := by simp |
| calc |
| _ ≤ eligibilityError * (ownSurvival.card : ℝ) + |
| (orbits.card : ℝ) * (N * ε * (ownSurvival.card : ℝ)) := |
| hu.trans (add_le_add heligible (horbits.trans hsum)) |
| _ = _ := by ring |
|
|
| theorem good_card_lower (ownSurvival : Finset Ω) (failure : Ω → Prop) (error : ℝ) |
| (hbad : ((ownSurvival.filter failure).card : ℝ) ≤ error * (ownSurvival.card : ℝ)) : |
| (1 - error) * (ownSurvival.card : ℝ) ≤ |
| ((ownSurvival.filter (fun ω => ¬ failure ω)).card : ℝ) := by |
| classical |
| have hsplit := Finset.card_filter_add_card_filter_not |
| (s := ownSurvival) failure |
| have hsplitR : ((ownSurvival.filter failure).card : ℝ) + |
| ((ownSurvival.filter (fun ω => ¬ failure ω)).card : ℝ) = |
| (ownSurvival.card : ℝ) := by exact_mod_cast hsplit |
| nlinarith |
|
|
| variable [DecidableEq V] |
|
|
| def retained (passing : Finset V) (bad : V → Ω → Prop) (ω : Ω) : Finset V := |
| passing.filter (fun v => ¬ bad v ω) |
|
|
| def deterministicLossFraction (full passing : Finset V) : ℝ := |
| ((full \ passing).card : ℝ) / (full.card : ℝ) |
|
|
| def missingFraction (full passing : Finset V) (bad : V → Ω → Prop) (ω : Ω) : ℝ := |
| ((full \ retained passing bad ω).card : ℝ) / (full.card : ℝ) |
|
|
| theorem missing_card_eq (full passing : Finset V) (bad : V → Ω → Prop) (ω : Ω) |
| (hpassing : passing ⊆ full) : |
| (full \ retained passing bad ω).card = |
| (full \ passing).card + randomLossCount passing bad ω := by |
| classical |
| have hkeep : retained passing bad ω ⊆ full := |
| (Finset.filter_subset _ _).trans hpassing |
| have h₁ := Finset.card_sdiff_add_card_eq_card hpassing |
| have h₂ := Finset.card_sdiff_add_card_eq_card hkeep |
| have h₃ := Finset.card_filter_add_card_filter_not |
| (s := passing) (fun v => bad v ω) |
| simp only [retained, randomLossCount] at * |
| omega |
|
|
| theorem missingFraction_eq (full passing : Finset V) (bad : V → Ω → Prop) (ω : Ω) |
| (hpassing : passing ⊆ full) : |
| missingFraction full passing bad ω = deterministicLossFraction full passing + |
| randomLossFraction full passing bad ω := by |
| unfold missingFraction deterministicLossFraction randomLossFraction |
| rw [missing_card_eq full passing bad ω hpassing, Nat.cast_add, add_div] |
|
|
| theorem good_missingFraction_le (orbits : Finset I) (full passing : I → Finset V) |
| (bad : I → V → Ω → Prop) (eligible : Ω → Prop) (C₀ N : ℝ) (ω : Ω) |
| (hgood : ¬ targetBad orbits full passing bad eligible N ω) |
| (hpassing : ∀ i ∈ orbits, passing i ⊆ full i) |
| (hdet : ∀ i ∈ orbits, deterministicLossFraction (full i) (passing i) ≤ C₀ / N) |
| (i : I) (hi : i ∈ orbits) : |
| missingFraction (full i) (passing i) (bad i) ω ≤ (C₀ + 1) / N := by |
| have hr : randomLossFraction (full i) (passing i) (bad i) ω ≤ 1 / N := by |
| apply le_of_not_gt |
| intro h |
| exact hgood (Or.inr ⟨i, hi, h⟩) |
| rw [missingFraction_eq (full i) (passing i) (bad i) ω (hpassing i hi)] |
| calc |
| _ ≤ C₀ / N + 1 / N := add_le_add (hdet i hi) hr |
| _ = _ := (add_div C₀ 1 N).symm |
|
|
| end MatrixMultiplication.JointLossCounts |
|
|
| end |
|
|
| end MatrixAllFields |
|
|
| end OAI |
|
|
