Download data/lean/OAI/Probability/LogConcave/JetEstimates/ContractLeftSplit.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 13.7 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/LogConcave/JetEstimates/ContractLeftSplit.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/LogConcave/JetEstimates/ContractLeftSplit.lean
-
curl -L -o ContractLeftSplit.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/LogConcave/JetEstimates/ContractLeftSplit.lean
13.7 kB
| import Mathlib | |
| import OAI.Probability.LogConcave.JetEstimates.WireStep | |
| import OAI.Probability.LogConcave.JetEstimates.ProperSplit | |
| import OAI.Probability.LogConcave.JetEstimates.Reindex | |
| namespace OAI | |
| section | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling.TensorEnergy | |
| open scoped Classical BigOperators | |
| universe u | |
| variable {Ai Ao Bi Bo : Type u} [Fintype Ai] [Fintype Ao] [Fintype Bi] [Fintype Bo] {d : β} | |
| def contractLeftSplit : ((Ai β Ao) β Unit) β (Ai β Unit) β Ao where | |
| toFun := Sum.elim (Sum.elim (Sum.inl β Sum.inl) Sum.inr) (Sum.inl β Sum.inr) | |
| invFun := Sum.elim (Sum.elim (Sum.inl β Sum.inl) Sum.inr) (Sum.inl β Sum.inr) | |
| left_inv s := by rcases s with (s|s)|s <;> rfl | |
| right_inv s := by rcases s with (s|s)|s <;> rfl | |
| def contractRightSplit : ((Bi β Bo) β Unit) β Bi β (Unit β Bo) where | |
| toFun := Sum.elim (Sum.elim Sum.inl (Sum.inr β Sum.inr)) (Sum.inr β Sum.inl) | |
| invFun := Sum.elim (Sum.inl β Sum.inl) (Sum.elim Sum.inr (Sum.inl β Sum.inr)) | |
| left_inv s := by rcases s with (s|s)|s <;> rfl | |
| right_inv s := by rcases s with s|(s|s) <;> rfl | |
| def appendCoordinate (I : Type u) : (I β Fin d) Γ Fin d β (I β Unit β Fin d) := | |
| ((Equiv.refl _).prodCongr (Equiv.funUnique Unit (Fin d)).symm).trans | |
| (Equiv.sumArrowEquivProdArrow I Unit (Fin d)).symm | |
| def prependCoordinate (O : Type u) : Fin d Γ (O β Fin d) β (Unit β O β Fin d) := | |
| (((Equiv.funUnique Unit (Fin d)).symm).prodCongr (Equiv.refl _)).trans | |
| (Equiv.sumArrowEquivProdArrow Unit O (Fin d)).symm | |
| lemma allSplit_contract_oriented [Nonempty Ao] [Nonempty Bi] | |
| {A : ((Ai β Ao) β Unit β Fin d) β β} | |
| {B : ((Bi β Bo) β Unit β Fin d) β β} {M N : β} | |
| (hA : AllSplitBound A M) (hB : AllSplitBound B N) : | |
| Bound (fun (o : (Ao β Fin d) Γ (Bo β Fin d)) (i : (Ai β Fin d) Γ (Bi β Fin d)) => | |
| βz : Fin d,A (Sum.elim (Sum.elim i.1 o.1) (fun _ => z))* | |
| B (Sum.elim (Sum.elim i.2 o.2) (fun _ => z))) ((M*N)^2) := by | |
| have ha := (hA (Ai β Unit) Ao contractLeftSplit).reindex | |
| (Equiv.refl (Ao β Fin d)) (appendCoordinate Ai) | |
| have hb := (hB Bi (Unit β Bo) contractRightSplit).reindex | |
| (prependCoordinate Bo) (Equiv.refl (Bi β Fin d)) | |
| have hab := ha.contract hb (sq_nonneg M) | |
| convert hab using 1 | |
| Β· funext o i | |
| apply Finset.sum_congr rfl | |
| intro z hz | |
| congr 1 | |
| Β· congr 1 | |
| funext s | |
| rcases s with (s|s)|s <;> rfl | |
| Β· congr 1 | |
| funext s | |
| rcases s with (s|s)|s <;> rfl | |
| Β· ring | |
| lemma allSplit_contract_reverse [Nonempty Ai] [Nonempty Bo] | |
| {A : ((Ai β Ao) β Unit β Fin d) β β} | |
| {B : ((Bi β Bo) β Unit β Fin d) β β} {M N : β} | |
| (hA : AllSplitBound A M) (hB : AllSplitBound B N) : | |
| Bound (fun (o : (Ao β Fin d) Γ (Bo β Fin d)) (i : (Ai β Fin d) Γ (Bi β Fin d)) => | |
| βz : Fin d,A (Sum.elim (Sum.elim i.1 o.1) (fun _ => z))* | |
| B (Sum.elim (Sum.elim i.2 o.2) (fun _ => z))) ((M*N)^2) := by | |
| have h := (allSplit_contract_oriented hB hA).reindex | |
| (Equiv.prodComm (Ao β Fin d) (Bo β Fin d)) | |
| (Equiv.prodComm (Ai β Fin d) (Bi β Fin d)) | |
| simpa only [Equiv.prodComm_apply,Prod.swap_prod_mk,Prod.fst_swap,Prod.snd_swap,mul_comm] using h | |
| lemma allSplit_contract_either | |
| {A : ((Ai β Ao) β Unit β Fin d) β β} | |
| {B : ((Bi β Bo) β Unit β Fin d) β β} {M N : β} | |
| (hA : AllSplitBound A M) (hB : AllSplitBound B N) | |
| (ho : (Nonempty Ao β§ Nonempty Bi) β¨ (Nonempty Ai β§ Nonempty Bo)) : | |
| Bound (fun (o : (Ao β Fin d) Γ (Bo β Fin d)) (i : (Ai β Fin d) Γ (Bi β Fin d)) => | |
| βz : Fin d,A (Sum.elim (Sum.elim i.1 o.1) (fun _ => z))* | |
| B (Sum.elim (Sum.elim i.2 o.2) (fun _ => z))) ((M*N)^2) := by | |
| rcases ho with β¨_,_β©|β¨_,_β© | |
| Β· exact allSplit_contract_oriented hA hB | |
| Β· exact allSplit_contract_reverse hA hB | |
| def singleContract {S T : Type u} | |
| (A : (S β Unit β Fin d) β β) (B : (T β Unit β Fin d) β β) : | |
| (S β T β Fin d) β β := fun c => | |
| βz : Fin d,A (Sum.elim (fun s => c (Sum.inl s)) (fun _ => z))* | |
| B (Sum.elim (fun t => c (Sum.inr t)) (fun _ => z)) | |
| section partition | |
| variable {S T : Type u} [Fintype S] [Fintype T] | |
| local instance leftInDec (p : S β T β Bool) : DecidableEq {s : S // p (Sum.inl s)=true} := Classical.decEq _ | |
| local instance leftOutDec (p : S β T β Bool) : DecidableEq {s : S // Β¬p (Sum.inl s)=true} := Classical.decEq _ | |
| local instance rightInDec (p : S β T β Bool) : DecidableEq {t : T // p (Sum.inr t)=true} := Classical.decEq _ | |
| local instance rightOutDec (p : S β T β Bool) : DecidableEq {t : T // Β¬p (Sum.inr t)=true} := Classical.decEq _ | |
| def partEquiv (p : S β Bool) : S β {s // p s=true} β {s // Β¬p s=true} := | |
| (Equiv.sumCompl (fun s => p s=true)).symm | |
| def outputCoords (p : ProperSplit (S β T)) : | |
| (OutSlots p β Fin d) β | |
| ({s : S // Β¬p.val (Sum.inl s)=true} β Fin d) Γ | |
| ({t : T // Β¬p.val (Sum.inr t)=true} β Fin d) := | |
| (Equiv.arrowCongr Equiv.subtypeSum (Equiv.refl (Fin d))).trans | |
| (Equiv.sumArrowEquivProdArrow _ _ (Fin d)) | |
| def inputCoords (p : ProperSplit (S β T)) : | |
| (InSlots p β Fin d) β | |
| ({s : S // p.val (Sum.inl s)=true} β Fin d) Γ | |
| ({t : T // p.val (Sum.inr t)=true} β Fin d) := | |
| (Equiv.arrowCongr Equiv.subtypeSum (Equiv.refl (Fin d))).trans | |
| (Equiv.sumArrowEquivProdArrow _ _ (Fin d)) | |
| omit [Fintype S] [Fintype T] in | |
| lemma splitOrientation [Nonempty S] [Nonempty T] (p : ProperSplit (S β T)) : | |
| (Nonempty {s : S // Β¬p.val (Sum.inl s)=true} β§ | |
| Nonempty {t : T // p.val (Sum.inr t)=true}) β¨ | |
| (Nonempty {s : S // p.val (Sum.inl s)=true} β§ | |
| Nonempty {t : T // Β¬p.val (Sum.inr t)=true}) := by | |
| by_cases hs : Nonempty {s : S // Β¬p.val (Sum.inl s)=true} | |
| Β· by_cases ht : Nonempty {t : T // p.val (Sum.inr t)=true} | |
| Β· exact Or.inl β¨hs,htβ© | |
| Β· right | |
| constructor | |
| Β· obtain β¨s,hβ© := p.property.1 | |
| cases s with | |
| | inl s => exact β¨s,hβ© | |
| | inr t => exact (ht β¨t,hβ©).elim | |
| Β· obtain β¨tβ© := βΉNonempty TβΊ | |
| exact β¨t,fun h => ht β¨t,hβ©β© | |
| Β· right | |
| constructor | |
| Β· obtain β¨sβ© := βΉNonempty SβΊ | |
| exact β¨s,by by_contra h; exact hs β¨s,hβ©β© | |
| Β· obtain β¨s,hβ© := p.property.2 | |
| cases s with | |
| | inl s => exact (hs β¨s,by simp [h]β©).elim | |
| | inr t => exact β¨t,by simp [h]β© | |
| omit [Fintype S] [Fintype T] in | |
| lemma part_colors_left (p : ProperSplit (S β T)) | |
| (o : OutSlots p β Fin d) (i : InSlots p β Fin d) (s : S) : | |
| Sum.elim (inputCoords p i).1 (outputCoords p o).1 | |
| (partEquiv (fun s : S => p.val (Sum.inl s)) s) = | |
| Sum.elim i o (splitEquiv p (Sum.inl s)) := by | |
| change Sum.elim (fun x : {s : S // p.val (Sum.inl s)=true} => i β¨Sum.inl x.val,x.propertyβ©) | |
| (fun x : {s : S // Β¬p.val (Sum.inl s)=true} => o β¨Sum.inl x.val,x.propertyβ©) | |
| (if h : p.val (Sum.inl s)=true then Sum.inl β¨s,hβ© else Sum.inr β¨s,hβ©) = | |
| Sum.elim i o (if h : p.val (Sum.inl s)=true | |
| then Sum.inl β¨Sum.inl s,hβ© else Sum.inr β¨Sum.inl s,hβ©) | |
| split <;> rfl | |
| omit [Fintype S] [Fintype T] in | |
| lemma part_colors_right (p : ProperSplit (S β T)) | |
| (o : OutSlots p β Fin d) (i : InSlots p β Fin d) (t : T) : | |
| Sum.elim (inputCoords p i).2 (outputCoords p o).2 | |
| (partEquiv (fun t : T => p.val (Sum.inr t)) t) = | |
| Sum.elim i o (splitEquiv p (Sum.inr t)) := by | |
| change Sum.elim (fun x : {t : T // p.val (Sum.inr t)=true} => i β¨Sum.inr x.val,x.propertyβ©) | |
| (fun x : {t : T // Β¬p.val (Sum.inr t)=true} => o β¨Sum.inr x.val,x.propertyβ©) | |
| (if h : p.val (Sum.inr t)=true then Sum.inl β¨t,hβ© else Sum.inr β¨t,hβ©) = | |
| Sum.elim i o (if h : p.val (Sum.inr t)=true | |
| then Sum.inl β¨Sum.inr t,hβ© else Sum.inr β¨Sum.inr t,hβ©) | |
| split <;> rfl | |
| lemma singleContract_split_bound [Nonempty S] [Nonempty T] | |
| {A : (S β Unit β Fin d) β β} {B : (T β Unit β Fin d) β β} | |
| {M N : β} (hA : AllSplitBound A M) (hB : AllSplitBound B N) | |
| (p : ProperSplit (S β T)) : | |
| Bound (splitMatrix (singleContract A B) p) ((M*N)^2) := by | |
| let eS := partEquiv (fun s : S => p.val (Sum.inl s)) | |
| let eT := partEquiv (fun t : T => p.val (Sum.inr t)) | |
| have ha := hA.reindex (eS.sumCongr (Equiv.refl Unit)) | |
| have hb := hB.reindex (eT.sumCongr (Equiv.refl Unit)) | |
| have h : Bound (fun (o : ({s : S // Β¬p.val (Sum.inl s)=true} β Fin d) Γ | |
| ({t : T // Β¬p.val (Sum.inr t)=true} β Fin d)) | |
| (i : ({s : S // p.val (Sum.inl s)=true} β Fin d) Γ | |
| ({t : T // p.val (Sum.inr t)=true} β Fin d)) => | |
| βz : Fin d,A ((Sum.elim (Sum.elim i.1 o.1) (fun _ => z)) β eS.sumCongr (Equiv.refl Unit))* | |
| B ((Sum.elim (Sum.elim i.2 o.2) (fun _ => z)) β eT.sumCongr (Equiv.refl Unit))) | |
| ((M*N)^2) := by | |
| exact allSplit_contract_either | |
| (Ai:={s : S // p.val (Sum.inl s)=true}) | |
| (Ao:={s : S // Β¬p.val (Sum.inl s)=true}) | |
| (Bi:={t : T // p.val (Sum.inr t)=true}) | |
| (Bo:={t : T // Β¬p.val (Sum.inr t)=true}) | |
| (A:=fun f => A (f β eS.sumCongr (Equiv.refl Unit))) | |
| (B:=fun f => B (f β eT.sumCongr (Equiv.refl Unit))) ha hb (splitOrientation p) | |
| have hh := h.reindex (outputCoords p) (inputCoords p) | |
| suffices he : splitMatrix (singleContract A B) p = | |
| (fun o i => βz : Fin d, | |
| A ((Sum.elim (Sum.elim (inputCoords p i).1 (outputCoords p o).1) (fun _ => z)) β | |
| eS.sumCongr (Equiv.refl Unit))* | |
| B ((Sum.elim (Sum.elim (inputCoords p i).2 (outputCoords p o).2) (fun _ => z)) β | |
| eT.sumCongr (Equiv.refl Unit))) by | |
| rw [he] | |
| exact hh | |
| ext o i | |
| unfold splitMatrix singleContract | |
| apply Finset.sum_congr rfl | |
| intro z hz | |
| congr 1 | |
| Β· congr 1 | |
| funext s | |
| rcases s with s|s | |
| Β· exact (part_colors_left p o i s).symm | |
| Β· rfl | |
| Β· congr 1 | |
| funext t | |
| rcases t with t|t | |
| Β· exact (part_colors_right p o i t).symm | |
| Β· rfl | |
| end partition | |
| end LogConcaveSampling.TensorEnergy | |
| namespace LogConcaveSampling.TensorEnergy | |
| open scoped Classical | |
| universe u | |
| lemma allSplitBound_of_proper {S : Type u} [Fintype S] {d : β} | |
| {T : (S β Fin d) β β} {M : β} | |
| (h : βp : ProperSplit S,Bound (splitMatrix T p) (M^2)) : AllSplitBound T M := by | |
| intro I O _ _ _ _ _ _ e | |
| have h' := (h (properOfEquiv e)).reindex | |
| (Equiv.arrowCongr (rightOfEquiv e) (Equiv.refl (Fin d))) | |
| (Equiv.arrowCongr (leftOfEquiv e) (Equiv.refl (Fin d))) | |
| convert h' using 1 | |
| ext o i | |
| unfold splitMatrix | |
| congr 1 | |
| funext s | |
| rw [splitEquiv_ofEquiv] | |
| cases e s <;> simp | |
| lemma AllSplitBound.singleContract {S T : Type u} [Fintype S] [Fintype T] | |
| [Nonempty S] [Nonempty T] {d : β} | |
| {A : (S β Unit β Fin d) β β} {B : (T β Unit β Fin d) β β} | |
| {M N : β} (hA : AllSplitBound A M) (hB : AllSplitBound B N) : | |
| AllSplitBound (singleContract A B) (M*N) := | |
| allSplitBound_of_proper (singleContract_split_bound hA hB) | |
| end LogConcaveSampling.TensorEnergy | |
| end | |
| end | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling.TensorEnergy | |
| open scoped Classical BigOperators Matrix.Norms.L2Operator | |
| universe u | |
| variable {S : Type u} [Fintype S] {d : β} | |
| lemma AllSplitBound.mono {T : (S β Fin d) β β} {M N : β} | |
| (h : AllSplitBound T M) (hM : 0β€M) (hMN : Mβ€N) : AllSplitBound T N := by | |
| intro I O _ _ _ _ _ _ e | |
| exact (h I O e).mono (pow_le_pow_leftβ hM hMN 2) | |
| lemma AllSplitBound.const_mul {T : (S β Fin d) β β} {M : β} | |
| (h : AllSplitBound T M) (c : β) : AllSplitBound (fun a => c*T a) (c*M) := by | |
| intro I O _ _ _ _ _ _ e | |
| convert (h I O e).smul c using 1 | |
| ring | |
| lemma Bound.finite_sum_norm {I O J : Type*} [Fintype I] [Fintype O] [Fintype J] | |
| {A : J β Matrix O I β} {M : J β β} | |
| (hM : βj,0β€M j) (h : βj,Bound (A j) ((M j)^2)) : | |
| Bound (fun o i => βj,A j o i) ((βj,M j)^2) := by | |
| have he : (fun o i => βj,A j o i)=βj,A j := by | |
| ext o i | |
| exact (Matrix.sum_apply o i Finset.univ A).symm | |
| rw [he] | |
| apply (bound_iff_norm_le (Finset.sum_nonneg (fun j _ => hM j))).mpr | |
| exact (norm_sum_le _ _).trans (Finset.sum_le_sum (fun j _ => (h j).norm_le (hM j))) | |
| lemma AllSplitBound.finite_sum {J : Type*} [Fintype J] | |
| {T : J β (S β Fin d) β β} {M : J β β} | |
| (hM : βj,0β€M j) (h : βj,AllSplitBound (T j) (M j)) : | |
| AllSplitBound (fun a => βj,T j a) (βj,M j) := by | |
| intro I O _ _ _ _ _ _ e | |
| exact Bound.finite_sum_norm hM (fun j => h j I O e) | |
| lemma nonempty_properSplit (hS : 2β€Fintype.card S) : Nonempty (ProperSplit S) := by | |
| let : Nontrivial S := Fintype.one_lt_card_iff_nontrivial.mp (by omega) | |
| obtain β¨s,t,hstβ© := exists_pair_ne S | |
| exact β¨β¨fun x => decide (x=s),β¨s,by simpβ©,β¨t,by simp [Ne.symm hst]β©β©β© | |
| lemma AllSplitBound.entry_le {T : (S β Fin d) β β} {M : β} | |
| (h : AllSplitBound T M) (hM : 0β€M) (hS : 2β€Fintype.card S) (c : S β Fin d) : | |
| |T c|β€M := by | |
| obtain β¨pβ© := nonempty_properSplit hS | |
| have hh := (h _ _ (splitEquiv p)).entry_sq | |
| (fun o => c ((splitEquiv p).symm (Sum.inr o))) | |
| (fun i => c ((splitEquiv p).symm (Sum.inl i))) | |
| have he : (fun s => Sum.elim (fun i => c ((splitEquiv p).symm (Sum.inl i))) | |
| (fun o => c ((splitEquiv p).symm (Sum.inr o))) (splitEquiv p s))=c := by | |
| funext s | |
| have hs := (splitEquiv p).symm_apply_apply s | |
| cases hsp : splitEquiv p s <;> simp only [Sum.elim_inl,Sum.elim_inr] <;> | |
| simp only [hsp] at hs <;> rw [hs] | |
| rw [he] at hh | |
| exact (sq_le_sqβ (abs_nonneg _) hM).mp (by simpa only [sq_abs] using hh) | |
| end LogConcaveSampling.TensorEnergy | |
| end | |
| end | |
| end | |
| end OAI | |