Download data/lean/OAI/Probability/SKBarriers/Replicas/MatrixChain.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 7.65 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/SKBarriers/Replicas/MatrixChain.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/SKBarriers/Replicas/MatrixChain.lean
-
curl -L -o MatrixChain.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/SKBarriers/Replicas/MatrixChain.lean
7.65 kB
| import Mathlib | |
| import OAI.Probability.SKBarriers.Scalar.RankOneMatrix | |
| import OAI.Probability.SKBarriers.Replicas.VectorBranch | |
| namespace OAI | |
| section | |
| noncomputable section | |
| open scoped BigOperators | |
| open MeasureTheory ProbabilityTheory Set | |
| namespace SK.Analytic | |
| section Penalty | |
| variable {E : Type} [AddCommMonoid E] | |
| def chainSum (l : List (β Γ E)) : E := (l.map Prod.snd).sum | |
| def chainPotentialPenalty (F : E β β) : List (β Γ E) β E β β | |
| | [], _ => 0 | |
| | p::l, Q => p.1*(F (Q+p.2)-F Q)+chainPotentialPenalty F l (Q+p.2) | |
| @[simp] theorem chainSum_nil : chainSum ([] : List (β Γ E))=0 := rfl | |
| @[simp] theorem chainSum_cons (p : β Γ E) (l : List (β Γ E)) : | |
| chainSum (p::l)=p.2+chainSum l := rfl | |
| theorem chainSum_append (l r : List (β Γ E)) : chainSum (l++r)=chainSum l+chainSum r := by | |
| simp [chainSum,List.sum_append] | |
| theorem chainPotentialPenalty_append (F : E β β) (l r : List (β Γ E)) (Q : E) : | |
| chainPotentialPenalty F (l++r) Q=chainPotentialPenalty F l Q+ | |
| chainPotentialPenalty F r (Q+chainSum l) := by | |
| induction l generalizing Q with | |
| | nil => simp [chainPotentialPenalty] | |
| | cons p l ih => simp only [List.cons_append,chainPotentialPenalty,ih,chainSum_cons,add_assoc] | |
| theorem chainSum_ofFn (n : β) (p : Fin n β β Γ E) : chainSum (List.ofFn p)=β i,(p i).2 := by | |
| simp [chainSum,List.map_ofFn,List.sum_ofFn,Function.comp_def] | |
| def strictPrefix {n : β} (v : Fin n β E) (i : Fin n) : E := β j,if j < i then v j else 0 | |
| theorem strictPrefix_castSucc {n : β} (v : Fin (n+1) β E) (i : Fin n) : | |
| strictPrefix v i.castSucc=strictPrefix (fun j => v j.castSucc) i := by | |
| simp [strictPrefix,Fin.sum_univ_castSucc,not_lt_of_ge (Fin.le_last i.castSucc)] | |
| theorem strictPrefix_last (n : β) (v : Fin (n+1) β E) : | |
| strictPrefix v (Fin.last n)=β j : Fin n,v j.castSucc := by | |
| simp [strictPrefix,Fin.sum_univ_castSucc] | |
| theorem chainPotentialPenalty_ofFn (n : β) (F : E β β) (p : Fin n β β Γ E) (Q : E) : | |
| chainPotentialPenalty F (List.ofFn p) Q= | |
| β i,(p i).1*(F (Q+strictPrefix (fun j => (p j).2) i+(p i).2)- | |
| F (Q+strictPrefix (fun j => (p j).2) i)) := by | |
| induction n with | |
| | zero => simp [chainPotentialPenalty] | |
| | succ n ih => | |
| rw [List.ofFn_succ',List.concat_eq_append,chainPotentialPenalty_append,ih] | |
| simp only [chainPotentialPenalty,add_zero,chainSum_ofFn,Fin.sum_univ_castSucc, | |
| strictPrefix_castSucc,strictPrefix_last] | |
| end Penalty | |
| def rankOneMatrix {d : β} (b : Fin d β β) : Fin d β Fin d β β := fun i j => b i*b j | |
| def matrixChainCovariance {d : β} (l : List (β Γ (Fin d β β))) : Fin d β Fin d β β := | |
| chainSum (l.map (fun p => (p.1,rankOneMatrix p.2))) | |
| def matrixChainPenalty {d : β} (l : List (β Γ (Fin d β β))) (Q : Fin d β Fin d β β) : β := | |
| chainPotentialPenalty (matrixSquare d) (l.map (fun p => (p.1,rankOneMatrix p.2))) Q | |
| theorem rankOnePath_cons_castSucc {n d : β} (b : Fin n β Fin d β β) (i : Fin n) : | |
| rankOnePath d (Fin.cons 0 b) i.castSucc=strictPrefix (fun j => rankOneMatrix (b j)) i := by | |
| funext u v | |
| simp only [rankOnePath,strictPrefix,Fin.sum_univ_succ,Fin.cons_zero,Pi.zero_apply, | |
| zero_mul,ite_self,zero_add,Fin.cons_succ,Finset.sum_apply] | |
| apply Finset.sum_congr rfl | |
| intro j _ | |
| have he : j.succ β€ i.castSucc β j < i := by exact Fin.succ_le_castSucc_iff | |
| simp only [he] | |
| split_ifs <;> rfl | |
| theorem rankOnePath_cons_succ {n d : β} (b : Fin n β Fin d β β) (i : Fin n) : | |
| rankOnePath d (Fin.cons 0 b) i.succ= | |
| strictPrefix (fun j => rankOneMatrix (b j)) i+rankOneMatrix (b i) := by | |
| have H : rankOnePath d (Fin.cons 0 b) i.succ= | |
| rankOnePath d (Fin.cons 0 b) i.castSucc+rankOneMatrix (b i) := by | |
| funext u v | |
| let c : Fin (n+1) β Fin d β β := Fin.cons 0 b | |
| have HH := finitePrefix_succ n (fun j => c j u*c j v) i | |
| simpa only [rankOnePath,finitePrefix,Pi.add_apply,rankOneMatrix,c,Fin.cons_succ] using HH | |
| rw [H,rankOnePath_cons_castSucc] | |
| theorem rankOnePath_cons_last {n d : β} (b : Fin n β Fin d β β) : | |
| rankOnePath d (Fin.cons 0 b) (Fin.last n)=β i,rankOneMatrix (b i) := by | |
| funext u v | |
| simp only [rankOnePath,Fin.le_last,ite_true,Fin.sum_univ_succ,Fin.cons_zero, | |
| Pi.zero_apply,zero_mul,zero_add,Fin.cons_succ,Finset.sum_apply,rankOneMatrix] | |
| theorem matrixConstrainedPressure_chain {N d : β} (hN : 0<N) (Ξ² : β) | |
| (D : Fin d β Fin d β β) (hD : Nonempty (MatrixStates N d D)) | |
| (l : List (β Γ (Fin d β β))) (hm : β pβl,p.1βIcc (0:β) 1) | |
| (hmono : l.Pairwise (fun p q => p.1β€q.1)) : | |
| matrixConstrainedPressure N d Ξ² D β€ | |
| vectorIncrementChain (l.map (fun p => (p.1,Ξ² β’ p.2))) | |
| (fun x => β u,scalarSpinTerminal (x u)) 0+ | |
| Ξ²^2/4*matrixSquare d (fun i j => D i j-matrixChainCovariance l i j)- | |
| Ξ²^2/4*matrixChainPenalty l 0 := by | |
| let m : Fin (l.length+1) β β := Fin.cons 0 (fun i => (l.get i).1) | |
| let b : Fin (l.length+1) β Fin d β β := Fin.cons 0 (fun i => (l.get i).2) | |
| have hm' : β i,m iβIcc (0:β) 1 := by | |
| intro i | |
| refine Fin.cases (by norm_num [m]) (fun j => ?_) i | |
| exact hm _ (List.get_mem l j) | |
| have hs : Monotone m := by | |
| have H : ((0,0)::l).Pairwise (fun p q => p.1β€q.1) := | |
| List.pairwise_cons.mpr β¨fun p hp => (hm p hp).1,hmonoβ© | |
| have HL : List.ofFn (Fin.cons (0,0) l.get)=(0,0)::l := by simp [List.ofFn_succ] | |
| rw [β HL,List.pairwise_ofFn] at H | |
| intro i j hij | |
| rcases lt_or_eq_of_le hij with hij|rfl | |
| Β· have hh := H hij | |
| have he (a : Fin (l.length+1)) : m a=((Fin.cons (0,0) l.get : Fin (l.length+1) β β Γ (Fin d β β)) a).1 := by | |
| refine Fin.cases rfl (fun _ => rfl) a | |
| simpa only [β he] using hh | |
| Β· exact le_rfl | |
| have H := matrixConstrainedPressure_rankOne hN Ξ² D hD m rfl hm' hs b | |
| have hv : vectorHierarchy (l.length+1) m (fun i => Ξ² β’ b i) | |
| (fun x => β u,scalarSpinTerminal (x u))= | |
| vectorIncrementChain (l.map (fun p => (p.1,Ξ² β’ p.2))) (fun x => β u,scalarSpinTerminal (x u)) := by | |
| rw [β vectorIncrementChain_ofFn] | |
| have he : (fun i => (m i,Ξ² β’ b i))=Fin.cons (0,0) (fun i => ((l.get i).1,Ξ² β’ (l.get i).2)) := by | |
| funext i; refine Fin.cases ?_ (fun _ => rfl) i | |
| simp [m,b] | |
| rw [he,List.ofFn_succ] | |
| simp only [Fin.cons_zero,Fin.cons_succ,vectorIncrementChain,vectorStep_zero] | |
| congr 1 | |
| simpa only [List.ofFn_get,Function.comp_def] using (List.map_ofFn (f:=l.get) (g:=fun p => (p.1,Ξ² β’ p.2))).symm | |
| have hc : rankOnePath d b (Fin.last l.length)=matrixChainCovariance l := by | |
| rw [rankOnePath_cons_last] | |
| unfold matrixChainCovariance | |
| have he : l.map (fun p => (p.1,rankOneMatrix p.2))= | |
| List.ofFn (fun i => ((l.get i).1,rankOneMatrix (l.get i).2)) := by | |
| simpa only [List.ofFn_get,Function.comp_def] using | |
| (List.map_ofFn (f:=l.get) (g:=fun p => (p.1,rankOneMatrix p.2))) | |
| rw [he,chainSum_ofFn] | |
| have hp : (β i : Fin l.length,m i.succ*(matrixSquare d (rankOnePath d b i.succ)- | |
| matrixSquare d (rankOnePath d b i.castSucc)))=matrixChainPenalty l 0 := by | |
| unfold matrixChainPenalty | |
| have he : l.map (fun p => (p.1,rankOneMatrix p.2))= | |
| List.ofFn (fun i => ((l.get i).1,rankOneMatrix (l.get i).2)) := by | |
| simpa only [List.ofFn_get,Function.comp_def] using | |
| (List.map_ofFn (f:=l.get) (g:=fun p => (p.1,rankOneMatrix p.2))) | |
| rw [he,chainPotentialPenalty_ofFn] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| simp only [m,Fin.cons_succ,b,rankOnePath_cons_succ,rankOnePath_cons_castSucc,zero_add] | |
| rw [hv,hc,hp] at H | |
| exact H | |
| end SK.Analytic | |
| end | |
| end | |
| end OAI | |