import OAI.Analysis.FreeEntropy.SemicircularSeries

namespace OAI

universe u1 u2 u3 u4

noncomputable section
namespace FiniteEntropySeparation.FreeSeries
open Finset
variable {α : Type} [DecidableEq α] [Fintype α]

def rightDeriv (i : α) (f : Series α) : Series α := fun w => f (w ++ [i])
def Cyclic (f : Series α) : Prop := ∀ i, deriv i f = rightDeriv i f
@[simp] theorem rightDeriv_apply {α : Type} [DecidableEq α] [Fintype α] (i : α) (f : Series α) (w : List α) :
    rightDeriv i f w = f (w ++ [i]) := rfl
 theorem rightDeriv_conv {α : Type} [DecidableEq α] [Fintype α] (i : α) (f g : Series α) :
    rightDeriv i (conv f g) = conv f (rightDeriv i g) + g [] • rightDeriv i f := by
  funext w
  induction w generalizing f with
  | nil => simp [rightDeriv, deriv, conv]; ring
  | cons a w ih =>
    change f [] * g ((a::w)++[i]) + conv (deriv a f) g (w++[i]) =
      (f [] * g ((a::w)++[i]) + conv (deriv a f) (rightDeriv i g) w) +
      g [] * f ((a::w)++[i])
    have h := ih (deriv a f)
    change conv (deriv a f) g (w++[i]) = _ at h
    rw [h]
    simp only [Pi.add_apply, Pi.smul_apply, smul_eq_mul, rightDeriv_apply, deriv_apply, List.cons_append]
    ring
 theorem rightDeriv_conv' (i : α) (f g : Series α) :
    rightDeriv i (conv f g) = conv f (rightDeriv i g) + g [] • rightDeriv i f :=
  rightDeriv_conv i f g
@[simp] theorem rightDeriv_unit {α : Type} [DecidableEq α] [Fintype α] (i : α) : rightDeriv i (unit : Series α) = 0 := by
  funext w
  cases w <;> rfl
@[simp] theorem rightDeriv_zero {α : Type} [DecidableEq α] [Fintype α] (i : α) : rightDeriv i (0 : Series α) = 0 := rfl
 theorem rightDeriv_add {α : Type} [DecidableEq α] [Fintype α] (i : α) (f g : Series α) :
    rightDeriv i (f+g) = rightDeriv i f + rightDeriv i g := rfl
 theorem rightDeriv_sub {α : Type} [DecidableEq α] [Fintype α] (i : α) (f g : Series α) :
    rightDeriv i (f-g) = rightDeriv i f - rightDeriv i g := rfl
 theorem rightDeriv_smul {α : Type} [DecidableEq α] [Fintype α] (i : α) (c : ℂ) (f : Series α) :
    rightDeriv i (c • f) = c • rightDeriv i f := rfl
 theorem rightDeriv_sum {α : Type} [DecidableEq α] [Fintype α] {β : Type u1} (s : Finset β) (f : β → Series α) (i : α) :
    rightDeriv i (∑ b ∈ s, f b) = ∑ b ∈ s, rightDeriv i (f b) := by
  funext w
  simp [rightDeriv]
 theorem rightDeriv_letter {α : Type} [DecidableEq α] [Fintype α] (i j : α) : rightDeriv i (letter j) = if i=j then unit else 0 := by
  funext w
  cases w with
  | nil => by_cases h : i=j <;> simp [rightDeriv, letter, unit, h]
  | cons a w => cases w <;> by_cases h : i=j <;> simp [rightDeriv, letter, unit, h]
 theorem series_ext_right {α : Type} [DecidableEq α] [Fintype α] {f g : Series α} (hn : f [] = g [])
    (h : ∀ i, rightDeriv i f = rightDeriv i g) : f = g := by
  funext w
  induction w using List.reverseRecOn with
  | nil => exact hn
  | append_singleton w i _ => exact congrFun (h i) w

def rightAssemble (f : α → Series α) : Series α := ∑ i, conv (f i) (letter i)
@[simp] theorem rightAssemble_nil (f : α → Series α) : rightAssemble f [] = 0 := by
  simp [rightAssemble]
 theorem rightDeriv_assemble (f : α → Series α) (j : α) :
    rightDeriv j (rightAssemble f) = f j := by
  rw [rightAssemble, rightDeriv_sum]
  simp only [rightDeriv_conv, rightDeriv_letter, letter_nil, zero_smul, add_zero]
  have hh (i : α) : conv (f i) (if j=i then unit else 0) = if j=i then f i else 0 := by
    split_ifs <;> simp
  simp_rw [hh]
  simp
 theorem assemble_rightDeriv (f : Series α) :
    rightAssemble (fun i => rightDeriv i f) = f - f [] • unit := by
  apply series_ext_right
  · simp
  · intro i
    simp [rightDeriv_assemble, rightDeriv_sub, rightDeriv_smul]
 theorem Cyclic.assemble {f : Series α} (hf : Cyclic f) :
    rightAssemble (fun i => deriv i f) = f - f [] • unit := by
  have hh : (fun i => deriv i f) = (fun i => rightDeriv i f) := funext hf
  rw [hh, assemble_rightDeriv]
 theorem cyclic_of_assemble {f : Series α} (h : rightAssemble (fun i => deriv i f) = f - f [] • unit) :
    Cyclic f := by
  intro i
  have hh := congrArg (rightDeriv i) h
  simpa [rightDeriv_assemble, rightDeriv_sub, rightDeriv_smul] using hh

 theorem conv_sum_left {α : Type} [DecidableEq α] [Fintype α] {β : Type u2} (s : Finset β) (f : β → Series α) (g : Series α) :
    conv (∑ b ∈ s, f b) g = ∑ b ∈ s, conv (f b) g := by
  classical
  induction s using Finset.induction with
  | empty => simp
  | @insert b s hb ih => simp [sum_insert hb, conv_add_left, ih]
 theorem conv_sum_right {α : Type} [DecidableEq α] [Fintype α] {β : Type u3} (s : Finset β) (f : Series α) (g : β → Series α) :
    conv f (∑ b ∈ s, g b) = ∑ b ∈ s, conv f (g b) := by
  classical
  induction s using Finset.induction with
  | empty => simp
  | @insert b s hb ih => simp [sum_insert hb, conv_add_right, ih]
 theorem subst_sum {α : Type} [DecidableEq α] [Fintype α] {β : Type u4} (s : Finset β) (M : Series α) (f : β → Series α) :
    subst M (∑ b ∈ s, f b) = ∑ b ∈ s, subst M (f b) := by
  classical
  induction s using Finset.induction with
  | empty => simp
  | @insert b s hb ih => simp [sum_insert hb, subst_add, ih]
 theorem subst_letter {α : Type} [DecidableEq α] [Fintype α] (M : Series α) (i : α) : subst M (letter i) = conv (letter i) M := by
  funext w
  cases w with
  | nil => simp
  | cons j w => simp only [subst_letter_cons, conv_cons, letter_nil, zero_mul, zero_add,
      deriv_letter]; split_ifs <;> simp
 theorem subst_rightAssemble (M : Series α) (f : α → Series α) :
    subst M (rightAssemble f) = conv (rightAssemble (fun i => subst M (f i))) M := by
  simp only [rightAssemble, subst_sum, conv_sum_left, subst_mul, subst_letter, conv_assoc]

 theorem cyclic_cumulants {M : Series α} (hM : M [] = 1) (hc : Cyclic M) :
    Cyclic (cumulants M) := by
  let R := cumulants M
  have he : M = unit + subst M R := cumulants_equation hM
  have hd (i : α) : deriv i M = conv M (subst M (deriv i R)) := by
    funext w
    have h := congrFun he (i::w)
    simpa [subst_cons] using h
  have hi (i : α) : rightDeriv i (inverse M) = -subst M (deriv i R) := by
    have hh := congrArg (rightDeriv i) (inverse_conv hM)
    rw [rightDeriv_conv, rightDeriv_unit, hM, one_smul, ← hc i, hd i,
      ← conv_assoc, inverse_conv hM, conv_unit_left] at hh
    exact eq_neg_of_add_eq_zero_right hh
  have hinv : rightAssemble (fun i => subst M (deriv i R)) = unit - inverse M := by
    apply series_ext_right
    · simp
    · intro i
      simp [rightDeriv_assemble, rightDeriv_sub, hi]
  apply cyclic_of_assemble
  simp only [cumulants_nil, zero_smul, sub_zero]
  apply subst_injective hM
  rw [subst_rightAssemble, hinv, conv_sub_left, conv_unit_left, inverse_conv hM]
  exact (eq_sub_iff_add_eq.mpr (by simpa [add_comm] using he.symm)).symm

 theorem cyclic_moments {R : Series α} (hR : R [] = 0) (hc : Cyclic R) :
    Cyclic (moments R) := by
  let M := moments R
  have hM : M [] = 1 := moments_nil R
  have he : M = unit + subst M R := moments_eq hR
  let A := rightAssemble (fun i => subst M (deriv i R))
  have hr : subst M R = conv A M := by
    have h := hc.assemble
    rw [hR, zero_smul, sub_zero] at h
    rw [← h, subst_rightAssemble]
  have ha : unit - A = inverse M := by
    have hp : conv (unit - A) M = unit := by
      rw [conv_sub_left, conv_unit_left]
      rw [hr] at he
      exact sub_eq_iff_eq_add.mpr he
    calc
      unit - A = conv (unit - A) (conv M (inverse M)) := by rw [conv_inverse hM, conv_unit_right]
      _ = inverse M := by rw [← conv_assoc, hp, conv_unit_left]
  intro i
  have hi : rightDeriv i (inverse M) = -subst M (deriv i R) := by
    rw [← ha, rightDeriv_sub, rightDeriv_unit, sub_eq_add_neg, zero_add]
    change -rightDeriv i (rightAssemble _) = _
    rw [rightDeriv_assemble]
  have hh := congrArg (rightDeriv i) (conv_inverse hM)
  rw [rightDeriv_conv, rightDeriv_unit, inverse_nil, one_smul, hi, conv_neg_right] at hh
  have hh' : rightDeriv i M = conv M (subst M (deriv i R)) := by
    exact eq_of_sub_eq_zero (by rw [sub_eq_add_neg]; simpa [add_comm] using hh)
  rw [hh']
  funext w
  have h := congrFun he (i::w)
  simpa [subst_cons] using h

end FiniteEntropySeparation.FreeSeries

end

end OAI