import Mathlib

namespace OAI

noncomputable section

namespace KKFreeWords

open scoped BigOperators

section

variable {R ι : Type*} [Semiring R]

variable (C A K : ι → R)

def cutSum : List ι → R
  | [] => 1
  | i :: w => C i * cutSum w + (A i + K i) * (w.map A).prod

def CutCompatible (i j : ι) : Prop :=
  A i * C j = 0 ∧ K i * C j = 0 ∧ A i * K j = 0 ∧ K i * K j = 0

theorem noncreation_cutSum (i j : ι) (w : List ι)
    (h : CutCompatible C A K i j) :
    (A i + K i) * cutSum C A K (j :: w) =
      (A i + K i) * ((j :: w).map A).prod := by
  rcases h with ⟨hAC, hKC, hAK, hKK⟩
  simp only [cutSum, List.map_cons, List.prod_cons, mul_add, add_mul,
    ← mul_assoc, hAC, hKC, hAK, hKK, zero_mul, zero_add, add_zero]

theorem product_eq_cutSum (w : List ι) (hw : w.IsChain (CutCompatible C A K)) :
    (w.map (fun i => C i + A i + K i)).prod = cutSum C A K w := by
  induction w with
  | nil => simp [cutSum]
  | cons i w ih =>
    rw [List.isChain_cons] at hw
    rw [List.map_cons, List.prod_cons, ih hw.2, cutSum, add_assoc, add_mul]
    congr 1
    cases w with
    | nil => simp [cutSum]
    | cons j w => exact noncreation_cutSum C A K i j w (hw.1 j (by simp))

theorem cutSum_map {κ : Type*} (f : κ → ι) (w : List κ) :
    cutSum C A K (w.map f) = cutSum (C ∘ f) (A ∘ f) (K ∘ f) w := by
  induction w with
  | nil => rfl
  | cons i w ih => simp only [cutSum, List.map_cons, ih, List.map_map]; rfl

def noPresCut {n : ℕ} (C A : Fin n → R) (k : ℕ) : R :=
  ((List.ofFn C).take k).prod * ((List.ofFn A).drop k).prod

def presCut {n : ℕ} (C A K : Fin n → R) (j : Fin n) : R :=
  ((List.ofFn C).take j).prod * K j * ((List.ofFn A).drop (j+1)).prod

theorem cutSum_eq_cuts {n : ℕ} (C A K : Fin n → R) :
    cutSum C A K (List.ofFn id) =
      (∑ p : Fin (n+1), noPresCut C A p) + ∑ j : Fin n, presCut C A K j := by
  induction n with
  | zero => simp [cutSum, noPresCut, presCut]
  | succ n ih =>
    rw [List.ofFn_succ]
    simp only [id_eq]
    rw [cutSum]
    have htail : cutSum C A K (List.ofFn (fun j : Fin n => j.succ)) =
        cutSum (fun j => C j.succ) (fun j => A j.succ) (fun j => K j.succ)
          (List.ofFn id) := by
      simpa only [List.map_ofFn, Function.comp_def, id_eq] using
        cutSum_map C A K Fin.succ (List.ofFn (id : Fin n → Fin n))
    rw [htail, ih,
      Fin.sum_univ_succ (fun p : Fin (n+2) => noPresCut C A p),
      Fin.sum_univ_succ (fun j : Fin (n+1) => presCut C A K j)]
    simp only [noPresCut, presCut, List.ofFn_succ, List.take_zero, List.prod_nil,
      List.drop_zero, one_mul, List.take_succ_cons, List.drop_succ_cons,
      List.prod_cons, Fin.val_zero, Fin.val_succ,
      List.map_ofFn, Function.comp_def]
    simp only [mul_add, add_mul, Finset.mul_sum, mul_assoc]
    abel

end

end KKFreeWords
end

end OAI