openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /JointExtraction /LossCounts.lean
| import OAI.LinearAlgebra.MatrixMultiplication.Entropy.ComplexFiniteEntropy | |
| import OAI.LinearAlgebra.MatrixMultiplication.Separation.ComplexSeparationCounting | |
| import Mathlib.Tactic.Linarith | |
| namespace OAI | |
| /-! Joint tensor extraction, compatibility and entropy estimates. -/ | |
| 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 | |
| section MissingVariables | |
| 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 MissingVariables | |
| end MatrixMultiplication.JointLossCounts | |
| end | |
| end OAI | |