introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
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