Download data/lean/OAI/Combinatorics/PerfectMatching/Coupling.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 7.73 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/PerfectMatching/Coupling.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Combinatorics/PerfectMatching/Coupling.lean
-
curl -L -o Coupling.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/PerfectMatching/Coupling.lean
7.73 kB
| import OAI.Combinatorics.PerfectMatching.Simplex | |
| namespace OAI | |
| /-! | |
| Finite pushforwards and couplings with a prescribed common marginal. | |
| -/ | |
| noncomputable section | |
| open scoped BigOperators Topology | |
| open Filter | |
| namespace MatchingEntropy | |
| /-- Finite pushforward weights. -/ | |
| def fiberMass {A C : Type*} [Fintype A] [DecidableEq C] | |
| (p : A β β) (f : A β C) (c : C) : β := β a, if f a = c then p a else 0 | |
| theorem fiberMass_nonneg {A C : Type*} [Fintype A] [DecidableEq C] | |
| {p : A β β} (hp : β a, 0 β€ p a) (f : A β C) (c : C) : | |
| 0 β€ fiberMass p f c := by | |
| apply Finset.sum_nonneg | |
| intro a _ | |
| split <;> simp_all | |
| theorem le_fiberMass_self {A C : Type*} [Fintype A] [DecidableEq C] | |
| {p : A β β} (hp : β a, 0 β€ p a) (f : A β C) (a : A) : | |
| p a β€ fiberMass p f (f a) := by | |
| have h := Finset.single_le_sum (s := Finset.univ) (a := a) | |
| (f := fun b => if f b = f a then p b else 0) | |
| (by intro b _; split <;> simp_all) (Finset.mem_univ a) | |
| simpa only [fiberMass, ite_true] using h | |
| /-- The explicit cut-choice coupling. Only equal choices receive mass. -/ | |
| def jointLaw {A B C : Type*} [Fintype A] [Fintype B] [DecidableEq C] | |
| (p : A β β) (q : B β β) (f : A β C) (g : B β C) (z : A Γ B) : β := | |
| if f z.1 = g z.2 then p z.1*q z.2 / fiberMass p f (f z.1) else 0 | |
| theorem jointLaw_nonneg {A B C : Type*} [Fintype A] [Fintype B] [DecidableEq C] | |
| {p : A β β} {q : B β β} (hp : β a, 0 β€ p a) (hq : β b, 0 β€ q b) | |
| (f : A β C) (g : B β C) (z : A Γ B) : 0 β€ jointLaw p q f g z := by | |
| unfold jointLaw | |
| split | |
| Β· exact div_nonneg (mul_nonneg (hp _) (hq _)) (fiberMass_nonneg hp f _) | |
| Β· rfl | |
| theorem jointLaw_first {A B C : Type*} [Fintype A] [Fintype B] [DecidableEq C] | |
| {p : A β β} {q : B β β} (hp : β a, 0 β€ p a) | |
| (f : A β C) (g : B β C) (hcompat : β c, fiberMass p f c = fiberMass q g c) | |
| (a : A) : (β b, jointLaw p q f g (a,b)) = p a := by | |
| have heq : β b, jointLaw p q f g (a,b) = | |
| (p a / fiberMass p f (f a)) * (if g b=f a then q b else 0) := by | |
| intro b | |
| by_cases h : f a=g b | |
| Β· simp only [jointLaw, h, ite_true] | |
| ring | |
| Β· simp [jointLaw, h, Ne.symm h] | |
| simp_rw [heq] | |
| rw [β Finset.mul_sum] | |
| change p a / fiberMass p f (f a) * fiberMass q g (f a) = p a | |
| rw [β hcompat] | |
| by_cases hz : fiberMass p f (f a) = 0 | |
| Β· have ha : p a = 0 := le_antisymm (by simpa [hz] using le_fiberMass_self hp f a) (hp a) | |
| simp [ha] | |
| Β· exact div_mul_cancelβ _ hz | |
| theorem jointLaw_second {A B C : Type*} [Fintype A] [Fintype B] [DecidableEq C] | |
| {p : A β β} {q : B β β} (hq : β b, 0 β€ q b) | |
| (f : A β C) (g : B β C) (hcompat : β c, fiberMass p f c = fiberMass q g c) | |
| (b : B) : (β a, jointLaw p q f g (a,b)) = q b := by | |
| have heq : β a, jointLaw p q f g (a,b) = | |
| (q b / fiberMass q g (g b)) * (if f a=g b then p a else 0) := by | |
| intro a | |
| by_cases h : f a=g b | |
| Β· simp only [jointLaw, h, ite_true, β hcompat] | |
| ring | |
| Β· simp [jointLaw, h] | |
| simp_rw [heq] | |
| rw [β Finset.mul_sum] | |
| change q b / fiberMass q g (g b) * fiberMass p f (g b) = q b | |
| rw [hcompat] | |
| by_cases hz : fiberMass q g (g b) = 0 | |
| Β· have hb : q b = 0 := le_antisymm (by simpa [hz] using le_fiberMass_self hq g b) (hq b) | |
| simp [hb] | |
| Β· exact div_mul_cancelβ _ hz | |
| theorem jointLaw_mem_simplex {A B C : Type*} [Fintype A] [Fintype B] [DecidableEq C] | |
| {p : A β β} {q : B β β} (hp : p β probabilitySimplex A) (hq : q β probabilitySimplex B) | |
| (f : A β C) (g : B β C) (hcompat : β c, fiberMass p f c = fiberMass q g c) : | |
| jointLaw p q f g β probabilitySimplex (A Γ B) := by | |
| refine β¨jointLaw_nonneg hp.1 hq.1 f g, ?_β© | |
| rw [Fintype.sum_prod_type] | |
| simp_rw [jointLaw_first hp.1 f g hcompat] | |
| exact hp.2 | |
| theorem sum_subtype_supported {A : Type*} [Fintype A] (P : A β Prop) [DecidablePred P] | |
| (w : A β β) (hsupp : β a, Β¬P a β w a = 0) : | |
| (β a : {a // P a}, w a.val) = β a, w a := by | |
| have hh : (β a : {a // Β¬P a}, w a.val) = 0 := by | |
| apply Finset.sum_eq_zero | |
| intro a _ | |
| exact hsupp a.val a.property | |
| simpa only [hh, add_zero] using (Fintype.sum_subtype_add_sum_subtype P w) | |
| /-- No mass is lost in retaining only compatible pairs. -/ | |
| theorem compatible_jointLaw_mem_simplex {A B C : Type*} [Fintype A] [Fintype B] [DecidableEq C] | |
| {p : A β β} {q : B β β} (hp : p β probabilitySimplex A) (hq : q β probabilitySimplex B) | |
| (f : A β C) (g : B β C) (hcompat : β c, fiberMass p f c = fiberMass q g c) : | |
| (fun z : {z : A Γ B // f z.1=g z.2} => jointLaw p q f g z.val) β | |
| probabilitySimplex {z : A Γ B // f z.1=g z.2} := by | |
| refine β¨fun z => jointLaw_nonneg hp.1 hq.1 f g z.val, ?_β© | |
| rw [sum_subtype_supported (fun z : A Γ B => f z.1=g z.2) (jointLaw p q f g) | |
| (by intro z hz; simp [jointLaw, hz])] | |
| exact (jointLaw_mem_simplex hp hq f g hcompat).2 | |
| theorem fiberMass_sum {A C : Type*} [Fintype A] [Fintype C] [DecidableEq C] | |
| (p : A β β) (f : A β C) : β c, fiberMass p f c = β a, p a := by | |
| unfold fiberMass | |
| rw [Finset.sum_comm] | |
| simp | |
| theorem fiberMass_expect {A C : Type*} [Fintype A] [Fintype C] [DecidableEq C] | |
| (p : A β β) (f : A β C) (h : C β β) : | |
| β c, fiberMass p f c * h c = β a, p a*h (f a) := by | |
| unfold fiberMass | |
| simp_rw [Finset.sum_mul] | |
| rw [Finset.sum_comm] | |
| apply Finset.sum_congr rfl | |
| intro a _ | |
| simp only [ite_mul, zero_mul] | |
| simp | |
| theorem fiberMass_mem_simplex {A C : Type*} [Fintype A] [Fintype C] [DecidableEq C] | |
| {p : A β β} (hp : p β probabilitySimplex A) (f : A β C) : | |
| fiberMass p f β probabilitySimplex C := | |
| β¨fiberMass_nonneg hp.1 f, (fiberMass_sum p f).trans hp.2β© | |
| theorem jointLaw_expect_first {A B C : Type*} [Fintype A] [Fintype B] [DecidableEq C] | |
| {p : A β β} {q : B β β} (hp : β a, 0 β€ p a) | |
| (f : A β C) (g : B β C) (hcompat : β c, fiberMass p f c = fiberMass q g c) | |
| (h : A β β) : β z : A Γ B, jointLaw p q f g z * h z.1 = β a, p a*h a := by | |
| rw [Fintype.sum_prod_type] | |
| simp_rw [β Finset.sum_mul, jointLaw_first hp f g hcompat] | |
| theorem jointLaw_expect_second {A B C : Type*} [Fintype A] [Fintype B] [DecidableEq C] | |
| {p : A β β} {q : B β β} (hq : β b, 0 β€ q b) | |
| (f : A β C) (g : B β C) (hcompat : β c, fiberMass p f c = fiberMass q g c) | |
| (h : B β β) : β z : A Γ B, jointLaw p q f g z * h z.2 = β b, q b*h b := by | |
| rw [Fintype.sum_prod_type, Finset.sum_comm] | |
| simp_rw [β Finset.sum_mul, jointLaw_second hq f g hcompat] | |
| theorem compatible_jointLaw_expect_first {A B C : Type*} [Fintype A] [Fintype B] [DecidableEq C] | |
| {p : A β β} {q : B β β} (hp : β a, 0 β€ p a) | |
| (f : A β C) (g : B β C) (hcompat : β c, fiberMass p f c = fiberMass q g c) | |
| (h : A β β) : | |
| β z : {z : A Γ B // f z.1=g z.2}, jointLaw p q f g z.val * h z.val.1 = β a, p a*h a := by | |
| rw [sum_subtype_supported (fun z : A Γ B => f z.1=g z.2) | |
| (fun z => jointLaw p q f g z * h z.1) | |
| (by intro z hz; simp [jointLaw, hz])] | |
| exact jointLaw_expect_first hp f g hcompat h | |
| theorem compatible_jointLaw_expect_second {A B C : Type*} [Fintype A] [Fintype B] [DecidableEq C] | |
| {p : A β β} {q : B β β} (hq : β b, 0 β€ q b) | |
| (f : A β C) (g : B β C) (hcompat : β c, fiberMass p f c = fiberMass q g c) | |
| (h : B β β) : | |
| β z : {z : A Γ B // f z.1=g z.2}, jointLaw p q f g z.val * h z.val.2 = β b, q b*h b := by | |
| rw [sum_subtype_supported (fun z : A Γ B => f z.1=g z.2) | |
| (fun z => jointLaw p q f g z * h z.2) | |
| (by intro z hz; simp [jointLaw, hz])] | |
| exact jointLaw_expect_second hq f g hcompat h | |
| end MatchingEntropy | |
| end | |
| end OAI | |