lean/OAI/Probability/SKBarriers/Replicas/MatrixChain.lean

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