Download data/lean/OAI/LinearAlgebra/MatrixMultiplication/JointExtraction/LossCounts.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 12.7 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/LinearAlgebra/MatrixMultiplication/JointExtraction/LossCounts.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/LinearAlgebra/MatrixMultiplication/JointExtraction/LossCounts.lean
-
curl -L -o LossCounts.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/LinearAlgebra/MatrixMultiplication/JointExtraction/LossCounts.lean
12.7 kB
| 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 | |