Download data/lean/OAI/Probability/LogConcave/JetEstimates/WireStep.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 7.9 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/LogConcave/JetEstimates/WireStep.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/LogConcave/JetEstimates/WireStep.lean
-
curl -L -o WireStep.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/LogConcave/JetEstimates/WireStep.lean
7.9 kB
| import Mathlib | |
| import OAI.Probability.LogConcave.JetEstimates.Bound | |
| namespace OAI | |
| section | |
| section | |
| noncomputable section | |
| open MeasureTheory Filter | |
| open scoped ENNReal NNReal Topology | |
| section UpperProof | |
| open MeasureTheory ProbabilityTheory Filter | |
| open scoped ENNReal NNReal RealInnerProductSpace Topology | |
| open Function MeasureTheory Set Filter | |
| open scoped Topology NNReal | |
| namespace LogConcaveSampling.TensorEnergy | |
| open scoped BigOperators | |
| variable {I J K L : Type*} [Fintype I] [Fintype J] [Fintype K] [Fintype L] | |
| lemma Bound.comp {A : I β J β β} {B : J β K β β} {C D : β} | |
| (hA : Bound A C) (hB : Bound B D) (hC : 0β€C) : | |
| Bound (fun i k => β j,A i j*B j k) (C*D) := by | |
| intro v | |
| have he (i : I) : (β k,(β j,A i j*B j k)*v k)= | |
| β j,A i j*(β k,B j k*v k) := by | |
| simp only [Finset.sum_mul,Finset.mul_sum,mul_assoc] | |
| exact Finset.sum_comm | |
| simp_rw [he] | |
| exact (hA _).trans ((mul_le_mul_of_nonneg_left (hB v) hC).trans_eq (by ring)) | |
| lemma bound_identity [DecidableEq I] : Bound (fun i j : I => if i=j then (1:β) else 0) 1 := by | |
| intro v | |
| simp | |
| lemma Bound.contract {P : Type*} [Fintype P] | |
| {A : I β J Γ P β β} {B : P Γ K β L β β} {C D : β} | |
| (hA : Bound A C) (hB : Bound B D) (hC : 0β€C) : | |
| Bound (fun (i : I Γ K) (j : J Γ L) => β p,A i.1 (j.1,p)*B (p,i.2) j.2) (C*D) := by | |
| classical | |
| have hβ := hA.kronecker (bound_identity (I:=K)) hC | |
| have hβ := (bound_identity (I:=J)).kronecker hB (by norm_num) | |
| have hβ' := hβ.reindex (Equiv.prodAssoc J P K) (Equiv.refl (JΓL)) | |
| have hh := hβ.comp hβ' (by simpa using hC) | |
| simp only [mul_one,one_mul] at hh | |
| convert! hh using 1 | |
| funext i j | |
| simp only [Fintype.sum_prod_type,Equiv.prodAssoc_apply,Equiv.refl_apply] | |
| simp [mul_ite,ite_mul] | |
| lemma Bound.entry_sq {A : I β J β β} {C : β} (hA : Bound A C) (i : I) (j : J) : | |
| (A i j)^2 β€ C := by | |
| classical | |
| have hh := hA (fun k => if k=j then 1 else 0) | |
| simp only [mul_ite,mul_one,mul_zero,Finset.sum_ite_eq',Finset.mem_univ,ite_true, | |
| ite_pow,one_pow,zero_pow (by decide : (2:β)β 0)] at hh | |
| exact (Finset.single_le_sum (fun k _ => sq_nonneg (A k j)) (Finset.mem_univ i)).trans hh | |
| lemma Bound.trace_sq {A : I β I β β} {C : β} (hA : Bound A C) : | |
| (β i,A i i)^2 β€ (Fintype.card I:β)^2*C := by | |
| have hh := dot_sq (fun _ : I => (1:β)) (fun i => A i i) | |
| simp only [one_mul,one_pow,Finset.sum_const,Finset.card_univ,nsmul_eq_mul,mul_one] at hh | |
| have hg := Finset.sum_le_sum (fun i (_ : iβ(Finset.univ:Finset I)) => hA.entry_sq i i) | |
| simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul] at hg | |
| exact hh.trans ((mul_le_mul_of_nonneg_left hg (Nat.cast_nonneg _)).trans_eq (by ring)) | |
| end LogConcaveSampling.TensorEnergy | |
| namespace LogConcaveSampling.TensorEnergy | |
| open scoped BigOperators | |
| def wireStep {I O S X Y : Type*} [DecidableEq S] | |
| (A : O β I β β) (ei : X β IΓS) (eo : Y β OΓS) : Y β X β β := | |
| fun y x => A (eo y).1 (ei x).1 * if (eo y).2=(ei x).2 then 1 else 0 | |
| lemma Bound.wireStep {I O S X Y : Type*} [Fintype I] [Fintype O] [Fintype S] | |
| [Fintype X] [Fintype Y] [DecidableEq S] {A : O β I β β} {C : β} | |
| (hA : Bound A C) (hC : 0β€C) (ei : X β IΓS) (eo : Y β OΓS) : | |
| Bound (wireStep A ei eo) C := by | |
| have hh := (hA.kronecker (bound_identity (I:=S)) hC).reindex eo ei | |
| change Bound (fun y x => A (eo y).1 (ei x).1 * if (eo y).2=(ei x).2 then 1 else 0) C | |
| simpa only [mul_one] using hh | |
| def circuit {D : β β Type*} [βk,Fintype (D k)] [DecidableEq (D 0)] | |
| (A : βk,D (k+1) β D k β β) : βn,D n β D 0 β β | |
| | 0 => fun i j => if i=j then 1 else 0 | |
| | n+1 => fun i j => βk,A n i k*circuit A n k j | |
| lemma circuit_bound {D : β β Type*} [βk,Fintype (D k)] [DecidableEq (D 0)] | |
| (A : βk,D (k+1) β D k β β) (C : β β β) | |
| (hC : βk,0β€C k) (hA : βk,Bound (A k) (C k)) (n : β) : | |
| Bound (circuit A n) (βkβFinset.range n,C k) := by | |
| induction n with | |
| | zero => simpa only [circuit,Finset.range_zero,Finset.prod_empty] using (bound_identity (I:=D 0)) | |
| | succ n ih => | |
| simpa only [circuit,Finset.prod_range_succ,mul_comm] using (hA n).comp ih (hC n) | |
| lemma Bound.trace_abs {I : Type*} [Fintype I] {A : I β I β β} {C : β} | |
| (hA : Bound A (C^2)) (hC : 0β€C) : |βi,A i i|β€(Fintype.card I:β)*C := by | |
| have hh := hA.trace_sq | |
| apply (sq_le_sqβ (abs_nonneg _) (mul_nonneg (Nat.cast_nonneg _) hC)).mp | |
| simpa only [sq_abs,mul_pow] using hh | |
| theorem closed_wire_circuit_bound | |
| {D I O S : β β Type*} [βk,Fintype (D k)] [βk,Fintype (I k)] | |
| [βk,Fintype (O k)] [βk,Fintype (S k)] [βk,DecidableEq (S k)] | |
| [DecidableEq (D 0)] | |
| (A : βk,O k β I k β β) (C : β β β) | |
| (hC : βk,0β€C k) (hA : βk,Bound (A k) ((C k)^2)) | |
| (ei : βk,D k β I kΓS k) (eo : βk,D (k+1) β O kΓS k) | |
| (n : β) (close : D 0 β D n) : | |
| |βi,circuit (fun k => wireStep (A k) (ei k) (eo k)) n (close i) i|β€ | |
| (Fintype.card (D 0):β)*(βkβFinset.range n,C k) := by | |
| have hlocal (k : β) : Bound (wireStep (A k) (ei k) (eo k)) ((C k)^2) := | |
| (hA k).wireStep (sq_nonneg _) (ei k) (eo k) | |
| have hh := (circuit_bound _ (fun k => (C k)^2) (fun k => sq_nonneg _) hlocal n).reindex | |
| close (Equiv.refl (D 0)) | |
| rw [Finset.prod_pow] at hh | |
| exact hh.trace_abs (Finset.prod_nonneg (fun k _ => hC k)) | |
| lemma cut_bundle_card (d b : β) : Fintype.card (Fin b β Fin d)=d^b := by simp | |
| end LogConcaveSampling.TensorEnergy | |
| namespace LogConcaveSampling.TensorEnergy | |
| open scoped BigOperators Classical | |
| variable {D : β β Type*} [βk,Fintype (D k)] [DecidableEq (D 0)] | |
| abbrev Path (n : β) := βk : Fin (n+1),D k.val | |
| def pathWeight (A : βk,D (k+1) β D k β β) (n : β) (h : Path (D:=D) n) : β := | |
| βk : Fin n,A k.val (h k.succ) (h k.castSucc) | |
| omit [βk,Fintype (D k)] [DecidableEq (D 0)] in | |
| lemma pathWeight_snoc (A : βk,D (k+1) β D k β β) (n : β) | |
| (h : Path (D:=D) n) (y : D (n+1)) : | |
| pathWeight A (n+1) (Fin.snoc (Ξ±:=fun k : Fin (n+2) => D k.val) h y)=pathWeight A n h*A n y (h (Fin.last n)) := by | |
| unfold pathWeight | |
| rw [Fin.prod_univ_castSucc] | |
| congr 1 | |
| Β· apply Finset.prod_congr rfl | |
| intro k hk | |
| change A k.val (Fin.snoc (Ξ±:=fun k : Fin (n+2) => D k.val) h y k.succ.castSucc) | |
| (Fin.snoc (Ξ±:=fun k : Fin (n+2) => D k.val) h y k.castSucc.castSucc) = _ | |
| simp only [Fin.snoc_castSucc] | |
| Β· simp only [Fin.succ_last,Fin.snoc_last,Fin.snoc_castSucc,Fin.val_last] | |
| theorem circuit_path_expansion (A : βk,D (k+1) β D k β β) (n : β) | |
| (B : D 0 β D n β β) : | |
| (βh : Path (D:=D) n,pathWeight A n h*B (h 0) (h (Fin.last n)))= | |
| βi,βj,circuit A n j i*B i j := by | |
| induction n with | |
| | zero => | |
| rw [β(Fin.consEquiv (fun k : Fin 1 => D k.val)).sum_comp] | |
| simp [pathWeight,circuit,Fintype.sum_prod_type] | |
| | succ n ih => | |
| rw [β(Fin.snocEquiv (fun k : Fin (n+2) => D k.val)).sum_comp] | |
| simp only [Fintype.sum_prod_type,Fin.snocEquiv_apply] | |
| change (βy : D (n+1),βh : Path (D:=D) n, | |
| pathWeight A (n+1) (Fin.snoc (Ξ±:=fun k : Fin (n+2) => D k.val) h y)* | |
| B (Fin.snoc (Ξ±:=fun k : Fin (n+2) => D k.val) h y (0 : Fin (n+1)).castSucc) | |
| (Fin.snoc (Ξ±:=fun k : Fin (n+2) => D k.val) h y (Fin.last (n+1))))=_ | |
| simp_rw [pathWeight_snoc,Fin.snoc_castSucc,Fin.snoc_last] | |
| have hh (y : D (n+1)) : | |
| (βh : Path (D:=D) n,pathWeight A n h*A n y (h (Fin.last n))*B (h 0) y)= | |
| βi,βj,circuit A n j i*(A n y j*B i y) := by | |
| simpa only [mul_assoc] using ih (fun i j => A n y j*B i y) | |
| simp_rw [hh] | |
| rw [Finset.sum_comm] | |
| apply Finset.sum_congr rfl | |
| intro i hi | |
| apply Finset.sum_congr rfl | |
| intro y hy | |
| simp only [circuit,Finset.sum_mul] | |
| apply Finset.sum_congr rfl | |
| intro j hj | |
| ring | |
| end LogConcaveSampling.TensorEnergy | |
| end UpperProof | |
| end | |
| end | |
| end | |
| end OAI | |