import Mathlib
import OAI.Probability.SKGap.Localization.SeparateCut
import OAI.Probability.SKGap.Matrix.InverseDiagram

namespace OAI

section
noncomputable section
noncomputable section
open scoped BigOperators
noncomputable section
namespace SKGap.Noncrossing
namespace Diagram
variable {D E : Type*}

def append : Diagram D → Diagram D → Diagram D
  | .nil, e => e
  | .diag a d, e => .diag a (d.append e)
  | .arch a b, e => .arch a (b.append e)

@[simp] lemma append_word (d e : Diagram D) : (d.append e).word = d.word ++ e.word := by
  induction d with
  | nil => rfl
  | diag a d ih => simp [append,word,ih]
  | arch a b ia ib => simp [append,word,ib,List.append_assoc]

@[simp] lemma append_nil (d : Diagram D) : d.append .nil = d := by
  induction d with
  | nil => rfl
  | diag a d ih => simp [append,ih]
  | arch a b ia ib => simp [append,ib]

lemma append_assoc (d e f : Diagram D) : (d.append e).append f = d.append (e.append f) := by
  induction d with
  | nil => rfl
  | diag a d ih => simp [append,ih]
  | arch a b ia ib => simp [append,ib]

def map (f : D → E) : Diagram D → Diagram E
  | .nil => .nil
  | .diag a d => .diag (f a) (d.map f)
  | .arch a b => .arch (a.map f) (b.map f)

def Letter.map (f : D → E) : Letter D → Letter E
  | .diag a => .diag (f a)
  | .noise => .noise

@[simp] lemma map_word (f : D → E) (d : Diagram D) :
    (d.map f).word = d.word.map (Letter.map f) := by
  induction d with
  | nil => rfl
  | diag a d ih => simp [map,word,ih,Letter.map]
  | arch a b ia ib => simp [map,word,ia,ib,Letter.map]

@[simp] lemma map_append (f : D → E) (d e : Diagram D) :
    (d.append e).map f = (d.map f).append (e.map f) := by
  induction d with
  | nil => rfl
  | diag a d ih => simp [map,append,ih]
  | arch a b ia ib => simp [map,append,ib]

lemma remove_last_diag (d : Diagram D) (F : List (Letter D)) (a : D)
    (h : d.word = F ++ [.diag a]) :
    ∃ e : Diagram D, e.word=F ∧ d=e.append (.diag a .nil) := by
  induction d generalizing F with
  | nil => simp [word] at h
  | diag b d ih =>
    cases F with
    | nil =>
      simp only [List.nil_append,word,List.cons.injEq] at h
      obtain ⟨hb,hd⟩ := h
      have hab : b=a := Letter.diag.inj hb
      subst b
      have he : d=.nil := by cases d <;> simp [word] at hd ⊢
      subst d
      exact ⟨.nil,rfl,rfl⟩
    | cons c F =>
      simp only [List.cons_append,word,List.cons.injEq] at h
      obtain ⟨rfl,hd⟩ := h
      obtain ⟨e,he,hd⟩ := ih F hd
      refine ⟨.diag b e,?_,?_⟩
      · simp [word,he]
      · simp [append,hd]
  | arch b d ib ih =>
    cases F with
    | nil => simp [word] at h
    | cons c F =>
      simp only [List.cons_append,word,List.cons.injEq] at h
      obtain ⟨rfl,hd⟩ := h
      have hdlen : b.word.length+1≤F.length := by
        have hh := congrArg List.length hd
        simp only [List.length_append,List.length_cons,List.length_nil] at hh
        by_contra hc
        have hef : d.word=[] := by
          apply List.length_eq_zero_iff.mp
          omega
        rw [hef] at hd
        have hlast := congrArg List.getLast? hd
        simp at hlast
      have he : F = b.word ++ (.noise :: F.drop (b.word.length+1)) := by
        have hh := congrArg (List.take (b.word.length+1)) hd
        rw [List.take_append_of_le_length (l₁ := F) (l₂ := [.diag a]) hdlen] at hh
        simp only [List.take_append,
          List.take_of_length_le (show b.word.length ≤ b.word.length+1 by omega),
          Nat.add_sub_cancel_left, List.take_succ_cons,List.take_zero] at hh
        have hb : F.take (b.word.length+1)=b.word++[.noise] := hh.symm
        calc
          F = F.take (b.word.length+1) ++ F.drop (b.word.length+1) :=
            (List.take_append_drop _ _).symm
          _ = _ := by rw [hb]; simp
      rw [he,List.append_assoc,List.cons_append,List.append_cancel_left_eq,
        List.cons.injEq] at hd
      obtain ⟨_,ht⟩ := hd
      obtain ⟨e,he',hde⟩ := ih _ ht
      refine ⟨.arch b e,?_,?_⟩
      · simpa [word,he'] using he.symm
      · simp [append,hde]

end Diagram
end SKGap.Noncrossing

noncomputable section
namespace SKGap.Noncrossing
namespace Diagram
variable {D : Type*}

@[simp] lemma append_size (d e : Diagram D) : (d.append e).size = d.size+e.size := by
  induction d with
  | nil => simp [append,size]
  | diag a d ih => simp [append,size,ih]; omega
  | arch a b ia ib => simp [append,size,ib]; omega

lemma append_last_diag_injective (a : D) :
    Function.Injective (fun d : Diagram D => d.append (.diag a .nil)) := by
  intro d
  induction d with
  | nil =>
    intro e he
    cases e with
    | nil => rfl
    | diag b e =>
      have ht : Diagram.nil = e.append (.diag a .nil) := (Diagram.diag.inj he).2
      have hs := congrArg size ht
      simp [size] at hs
    | arch b e => cases he
  | diag b d ih =>
    intro e he
    cases e with
    | nil =>
      have ht : d.append (.diag a .nil) = Diagram.nil := (Diagram.diag.inj he).2
      have hs := congrArg size ht
      simp [size] at hs
    | diag c e =>
      obtain ⟨rfl,ht⟩ := Diagram.diag.inj he
      rw [ih ht]
    | arch c e => cases he
  | arch b d ib ih =>
    intro e he
    cases e with
    | nil => cases he
    | diag c e => cases he
    | arch c e =>
      obtain ⟨rfl,ht⟩ := Diagram.arch.inj he
      rw [ih ht]

lemma value_append {ι : Type*} [Fintype ι] (j : ℝ) (d e : Diagram (ι→ℝ)) (i : ι) :
    (d.append e).value j i = d.value j i * e.value j i := by
  induction d with
  | nil => simp [append,value]
  | diag a d ih => simp [append,value,ih,mul_assoc]
  | arch a b ia ib => simp [append,value,ib,mul_assoc]

end Diagram
namespace InverseDiagram

def expandBlocks (bs : List Bool) : List (Letter Bool) :=
  bs.flatMap (fun b => if b then [.diag true,.noise] else [.diag false])

@[simp] lemma expandBlocks_nil : expandBlocks [] = [] := rfl
@[simp] lemma expandBlocks_false (bs : List Bool) :
    expandBlocks (false::bs) = .diag false :: expandBlocks bs := rfl
@[simp] lemma expandBlocks_true (bs : List Bool) :
    expandBlocks (true::bs) = .diag true :: .noise :: expandBlocks bs := rfl
@[simp] lemma expandBlocks_append (bs cs : List Bool) :
    expandBlocks (bs++cs) = expandBlocks bs ++ expandBlocks cs := by
  simp [expandBlocks]

lemma split_noise (bs : List Bool) (U V : List (Letter Bool))
    (h : expandBlocks bs = U ++ (.noise::V)) :
    ∃ p q : List Bool, bs=p++(true::q) ∧
      U=expandBlocks p++[.diag true] ∧ V=expandBlocks q := by
  induction bs generalizing U with
  | nil => simp at h
  | cons b bs ih =>
    cases b with
    | false =>
      cases U with
      | nil => simp at h
      | cons c U =>
        simp only [expandBlocks_false,List.cons_append,List.cons.injEq] at h
        obtain ⟨rfl,ht⟩ := h
        obtain ⟨p,q,hpq,hU,hV⟩ := ih U ht
        exact ⟨false::p,q,by simp [hpq],by simp [hU],hV⟩
    | true =>
      cases U with
      | nil => simp at h
      | cons c U =>
        simp only [expandBlocks_true,List.cons_append,List.cons.injEq] at h
        obtain ⟨rfl,ht⟩ := h
        cases U with
        | nil =>
          simp only [List.nil_append,List.cons.injEq,true_and] at ht
          exact ⟨[],bs,rfl,rfl,ht.symm⟩
        | cons c U =>
          simp only [List.cons_append,List.cons.injEq] at ht
          obtain ⟨rfl,ht⟩ := ht
          obtain ⟨p,q,hpq,hU,hV⟩ := ih U ht
          exact ⟨true::p,q,by simp [hpq],by simp [hU],hV⟩

def toDiagram : InverseDiagram → Diagram Bool
  | .empty => .nil
  | .counterterm d => .diag false (toDiagram d)
  | .arch u v => .diag true
      (.arch ((toDiagram u).append (.diag true .nil)) (toDiagram v))

@[simp] lemma toDiagram_word (d : InverseDiagram) :
    d.toDiagram.word = expandBlocks d.blocks := by
  induction d with
  | empty => rfl
  | counterterm d ih => simp [toDiagram,Diagram.word,blocks,ih]
  | arch u v iu iv => simp [toDiagram,Diagram.word,blocks,iu,iv,List.append_assoc]

lemma toDiagram_injective : Function.Injective toDiagram := by
  intro d
  induction d with
  | empty => intro e he; cases e <;> cases he; rfl
  | counterterm d ih =>
    intro e he
    cases e with
    | empty => cases he
    | counterterm e => exact congrArg counterterm (ih (Diagram.diag.inj he).2)
    | arch u v => cases he
  | arch u v iu iv =>
    intro e he
    cases e with
    | empty => cases he
    | counterterm e => cases he
    | arch x y =>
      have ht := Diagram.arch.inj (Diagram.diag.inj he).2
      rw [iu (Diagram.append_last_diag_injective true ht.1),iv ht.2]

lemma toDiagram_surjective (d : Diagram Bool) (bs : List Bool)
    (h : d.word=expandBlocks bs) :
    ∃ e : InverseDiagram, e.blocks=bs ∧ e.toDiagram=d := by
  induction hs : d.size using Nat.strong_induction_on generalizing d bs with
  | h n ih =>
    cases bs with
    | nil =>
      have hd : d=.nil := by cases d <;> simp [Diagram.word] at h ⊢
      subst d
      exact ⟨.empty,rfl,rfl⟩
    | cons b bs =>
      cases b with
      | false =>
        cases d with
        | nil => simp [Diagram.word] at h
        | arch u v => simp [Diagram.word] at h
        | diag a d =>
          simp only [Diagram.word,expandBlocks_false,List.cons.injEq,Letter.diag.injEq] at h
          obtain ⟨rfl,hd⟩ := h
          obtain ⟨e,he,hed⟩ := ih d.size (by simp [Diagram.size] at hs; omega) d bs hd rfl
          exact ⟨.counterterm e,by simp [blocks,he],by simp [toDiagram,hed]⟩
      | true =>
        cases d with
        | nil => simp [Diagram.word] at h
        | arch u v => simp [Diagram.word] at h
        | diag a d =>
          simp only [Diagram.word,expandBlocks_true,List.cons.injEq,Letter.diag.injEq] at h
          obtain ⟨rfl,hd⟩ := h
          cases d with
          | nil => simp [Diagram.word] at hd
          | diag a d => simp [Diagram.word] at hd
          | arch u v =>
            simp only [Diagram.word,List.cons.injEq,true_and] at hd
            obtain ⟨p,q,hbs,hu,hv⟩ := split_noise bs u.word v.word hd.symm
            obtain ⟨u',hu',huu⟩ := u.remove_last_diag (expandBlocks p) true hu
            have hnu : u'.size<n := by
              rw [huu] at hs
              simp only [Diagram.size,Diagram.append_size] at hs
              omega
            have hnv : v.size<n := by simp only [Diagram.size] at hs; omega
            obtain ⟨e,he,heu⟩ := ih u'.size hnu u' p hu' rfl
            obtain ⟨f,hf,hfv⟩ := ih v.size hnv v q hv rfl
            refine ⟨.arch e f,?_,?_⟩
            · simp [blocks,he,hf,hbs]
            · simp [toDiagram,heu,hfv,huu]

end InverseDiagram
end SKGap.Noncrossing

noncomputable section
open scoped BigOperators

end
end
end
end
end
end

end OAI