import OAI.Probability.FKMaps.CoreWords

namespace OAI

noncomputable section
open List Equiv Equiv.Perm
namespace FKCRT.Inventory

/-- The genuine finite ordered connected-core tree. Leaves carry exactly
the trivial word; every nonleaf has one child for each ordered core dart. -/
inductive CoreTree where
  | leaf : CoreTree
  | branch (core : Core) (children : Fin core.val.length→ CoreTree) : CoreTree

namespace CoreTree

def word : CoreTree→List TypedLetter
  | leaf => []
  | branch c ts => cornerInsert (cornerList c (fun i => (ts i).word))

lemma word_empty (t : CoreTree) : stackTypedRun t.word []=some [] := by
  induction t with
  | leaf => rfl
  | branch c ts ih =>
    apply ValidCorners.empty
    refine ⟨?_,?_⟩
    · rw [cornerList_fst];exact c.property
    · intro x hx
      obtain ⟨i,rfl⟩ := List.mem_ofFn.mp hx
      exact ih i

lemma branch_nonempty (c : Core) (ts : Fin c.val.length→ CoreTree) : (branch c ts).word≠[] := by
  apply ValidCorners.nonempty
  refine ⟨?_,?_⟩
  · rw [cornerList_fst];exact c.property
  · intro x hx
    obtain ⟨i,rfl⟩ := List.mem_ofFn.mp hx
    exact (ts i).word_empty

lemma word_injective : Function.Injective word := by
  intro t
  induction t with
  | leaf =>
    intro u h
    cases u with
    | leaf => rfl
    | branch c us => exact False.elim (branch_nonempty c us h.symm)
  | branch c ts ih =>
    intro u h
    cases u with
    | leaf => exact False.elim (branch_nonempty c ts h)
    | branch d us =>
      have hvc (c : Core) (ts : Fin c.val.length→ CoreTree) :
          ValidCorners (cornerList c (fun i => (ts i).word)) := by
        exact cornerList_valid c (fun i => ⟨(ts i).word,(ts i).word_empty⟩)
      have hh := valid_corner_injective (hvc c ts) (hvc d us) h
      have hcd := cornerList_congr_core hh
      subst d
      have hwords := cornerList_injective c hh
      have hts : ts=us := by
        funext i
        exact ih i (congrFun hwords i)
      rw [hts]

end CoreTree

lemma corner_child_short (l : List (TypedLetter×List TypedLetter))
    (x : TypedLetter×List TypedLetter) (hx : x∈l) : x.2.length<(cornerInsert l).length := by
  induction l with
  | nil => simp at hx
  | cons y l ih =>
    change x.2.length<((y.1::y.2)++cornerInsert l).length
    simp only [List.length_append,List.length_cons]
    rcases List.mem_cons.mp hx with rfl|hx
    · omega
    · have hh := ih hx;omega

/-- The finite recursive forest construction terminates because actual
corner words are strictly shorter. -/
theorem exists_core_tree (w : List TypedLetter) (hw : stackTypedRun w []=some []) :
    ∃ t : CoreTree,t.word=w := by
  induction hn : w.length using Nat.strong_induction_on generalizing w with
  | h n ih =>
    by_cases he : w=[]
    · exact ⟨.leaf,he.symm⟩
    let W : NonemptyTypedWord := ⟨⟨w,hw⟩,he⟩
    let d := coreChildrenEquiv.symm W
    have hd : cornerInsert (cornerList d.1 (fun i => (d.2 i).val))=w :=
      congrArg (fun w => w.val.val) (coreChildrenEquiv.apply_symm_apply W)
    have hshort (i : Fin d.1.val.length) : (d.2 i).val.length<n := by
      have hh := corner_child_short (cornerList d.1 (fun i => (d.2 i).val))
        (d.1.val.get i,(d.2 i).val) (List.mem_ofFn.mpr ⟨i,rfl⟩)
      rwa [hd,hn] at hh
    have hchild (i : Fin d.1.val.length) : ∃ t : CoreTree,t.word=(d.2 i).val :=
      ih _ (hshort i) _ (d.2 i).property rfl
    let ts := fun i => (hchild i).choose
    refine ⟨.branch d.1 ts,?_⟩
    change cornerInsert (cornerList d.1 (fun i => (ts i).word))=w
    have ht : (fun i => (ts i).word)=(fun i => (d.2 i).val) :=
      funext (fun i => (hchild i).choose_spec)
    rw [ht,hd]

namespace CoreTree

def toWord (t : CoreTree) : EmptyTypedWord := ⟨t.word,t.word_empty⟩

lemma toWord_bijective : Function.Bijective toWord := by
  constructor
  · intro t u h
    exact word_injective (congrArg Subtype.val h)
  · intro w
    obtain ⟨t,ht⟩ := exists_core_tree w.val w.property
    exact ⟨t,Subtype.ext ht⟩

/-- Full actual-word / normalized connected-core ordered-tree bijection. -/
def wordEquiv : CoreTree ≃ EmptyTypedWord := Equiv.ofBijective toWord toWord_bijective

end CoreTree
end FKCRT.Inventory
end


noncomputable section
open Set Filter MeasureTheory ProbabilityTheory
open scoped Topology BigOperators ENNReal NNReal
namespace FKCRT.TreeCoding

/-- Ordered rooted trees; the empty child list is an actual leaf. -/
inductive PlaneTree where
  | node : List PlaneTree → PlaneTree

noncomputable instance : DecidableEq PlaneTree := Classical.decEq _
namespace PlaneTree

@[elab_as_elim] theorem inductionMem {P : PlaneTree → Prop}
    (hn : ∀ ts, (∀ t ∈ ts, P t) → P (node ts)) (t : PlaneTree) : P t :=
  PlaneTree.rec (motive_1 := P) (motive_2 := fun ts => ∀ t ∈ ts, P t)
    hn (by simp) (by intro t ts ht hts t' ht'; rcases List.mem_cons.mp ht' with rfl | ht'; exact ht; exact hts _ ht') t

def degrees : PlaneTree → List ℕ
  | node ts => ts.length :: ts.flatMap degrees

def forestDegrees (ts : List PlaneTree) : List ℕ := ts.flatMap degrees

def build : List ℕ → List PlaneTree → List PlaneTree
  | [],ts => ts
  | k::l,ts => let fs := build l ts; node (fs.take k)::fs.drop k

lemma build_append (l l' : List ℕ) (ts : List PlaneTree) :
    build (l++l') ts=build l (build l' ts) := by
  induction l with
  | nil => rfl
  | cons k l ih => simp only [List.cons_append,build,ih]

lemma build_degrees (t : PlaneTree) (ts : List PlaneTree) : build t.degrees ts=t::ts := by
  induction t using inductionMem generalizing ts with
  | hn fs ih =>
    have hf : ∀ (fs' : List PlaneTree), (∀ f∈fs',∀ ts,build f.degrees ts=f::ts) →
        ∀ ts,build (fs'.flatMap degrees) ts=fs'++ts := by
      intro fs' hf ts
      induction fs' with
      | nil => rfl
      | cons f fs' ih' =>
        rw [List.flatMap_cons,build_append,hf f (by simp),ih' (by aesop)]
        rfl
    rw [degrees,build,hf fs (by exact ih)]
    simp

lemma build_forestDegrees (fs ts : List PlaneTree) : build (forestDegrees fs) ts=fs++ts := by
  induction fs with
  | nil => rfl
  | cons f fs ih =>
    change build (degrees f++forestDegrees fs) ts=(f::fs)++ts
    rw [build_append,ih,build_degrees]
    rfl

lemma degrees_injective : Function.Injective degrees := by
  intro t t' h
  have hh := congrArg (fun l => build l []) h
  simpa only [build_degrees,List.cons.injEq,and_true] using hh

lemma forestDegrees_injective : Function.Injective forestDegrees := by
  intro fs fs' h
  have hh := congrArg (fun l => build l []) h
  simpa only [build_forestDegrees,List.append_nil] using hh

def incrementWord (l : List ℕ) : List ℤ := l.map (fun k : ℕ => (k:ℤ)-1)

def SuffixNegative (l : List ℕ) : Prop := ∀ j<l.length,(incrementWord (l.drop j)).sum<0

lemma suffixNegative_tail {k : ℕ} {l : List ℕ} (h : SuffixNegative (k::l)) : SuffixNegative l := by
  intro j hj
  simpa only [List.drop_succ_cons] using h (j+1) (by simpa using hj)

lemma build_correct {l : List ℕ} (h : SuffixNegative l) :
    forestDegrees (build l [])=l ∧ ((build l []).length:ℤ)= -(incrementWord l).sum := by
  induction l with
  | nil => simp [build,forestDegrees,incrementWord]
  | cons k l ih =>
    obtain ⟨he,hlen⟩ := ih (suffixNegative_tail h)
    have hneg := h 0 (by simp)
    simp only [List.drop_zero,incrementWord,List.map_cons,List.sum_cons] at hneg
    have hk : k≤(build l []).length := by
      change ((build l []).length:ℤ)= -(incrementWord l).sum at hlen
      unfold incrementWord at hlen
      omega
    constructor
    · simp only [build, forestDegrees, List.flatMap_cons, degrees, List.cons_append]
      change ((List.take k (build l [])).length)::
        (forestDegrees (List.take k (build l []))++forestDegrees (List.drop k (build l [])))=k::l
      rw [List.length_take,Nat.min_eq_left hk]
      rw [forestDegrees, forestDegrees, ← List.flatMap_append, List.take_append_drop]
      exact congrArg (List.cons k) he
    · simp only [build,List.length_cons,List.length_drop,incrementWord,List.map_cons,List.sum_cons]
      rw [Nat.cast_add, Nat.cast_sub hk]
      simp only [Nat.cast_one]
      unfold incrementWord at hlen
      omega

lemma suffixNegative_of_excursion {l : List ℕ} (h : IsExcursionList (incrementWord l)) :
    SuffixNegative l := by
  intro j hj
  have hp := h.2 j (by simpa [incrementWord] using hj)
  have hh : (incrementWord (l.drop j)).sum=(incrementWord l).sum-prefixSum (incrementWord l) j := by
    rw [incrementWord,List.map_drop,sum_drop]
    rfl
  rw [hh,h.1]
  omega

lemma exists_tree_of_excursion {l : List ℕ} (h : IsExcursionList (incrementWord l)) :
    ∃ t : PlaneTree,t.degrees=l := by
  obtain ⟨he,hlen⟩ := build_correct (suffixNegative_of_excursion h)
  rw [h.1] at hlen
  have hlen' : (build l []).length=1 := by omega
  obtain ⟨t,ht⟩ := List.length_eq_one_iff.mp hlen'
  exact ⟨t,by simpa [ht,forestDegrees] using he⟩

/-- Reversal of all child orders, without imposing any symmetry on marks. -/
def mirror : PlaneTree → PlaneTree
  | node ts => node (ts.reverse.map mirror)

lemma mirror_mirror (t : PlaneTree) : t.mirror.mirror=t := by
  induction t using inductionMem with
  | hn ts ih =>
    simp only [mirror,List.map_reverse,List.reverse_reverse,List.map_map]
    congr 1
    apply Eq.trans ?_ (List.map_id' _)
    apply List.map_congr_left
    intro t ht
    exact ih t ht

lemma incrementWord_append (l l' : List ℕ) :
    incrementWord (l++l')=incrementWord l++incrementWord l' := by
  simp [incrementWord]

lemma suffixNegative_append {l l' : List ℕ} (h : SuffixNegative l)
    (h' : SuffixNegative l') (hs : (incrementWord l').sum≤0) : SuffixNegative (l++l') := by
  intro j hj
  by_cases hja : j<l.length
  · rw [List.drop_append_of_le_length (Nat.le_of_lt hja),incrementWord_append,List.sum_append]
    exact add_lt_of_lt_of_nonpos (h j hja) hs
  · rw [List.drop_append,List.drop_eq_nil_of_le (by omega : l.length≤j),List.nil_append]
    exact h' (j-l.length) (by simp only [List.length_append] at hj; omega)

lemma degrees_properties (t : PlaneTree) :
    (incrementWord t.degrees).sum= -1 ∧ SuffixNegative t.degrees := by
  induction t using inductionMem with
  | hn ts ih =>
    have hf : ∀ fs : List PlaneTree,
        (∀ f ∈ fs, (incrementWord f.degrees).sum= -1 ∧ SuffixNegative f.degrees) →
        (incrementWord (forestDegrees fs)).sum= -(fs.length:ℤ) ∧
          SuffixNegative (forestDegrees fs) := by
      intro fs hfs
      induction fs with
      | nil => simp [forestDegrees,incrementWord,SuffixNegative]
      | cons f fs ih' =>
        have hp := hfs f (by simp)
        obtain ⟨hs,hn⟩ := ih' (by intro f hf; exact hfs f (by simp [hf]))
        have he : forestDegrees (f::fs)=f.degrees++forestDegrees fs := by simp [forestDegrees]
        rw [he]
        constructor
        · rw [incrementWord_append,List.sum_append,hp.1,hs]
          simp only [List.length_cons,Nat.cast_add,Nat.cast_one]
          omega
        · exact suffixNegative_append hp.2 hn (by rw [hs]; omega)
    obtain ⟨hs,hn⟩ := hf ts ih
    have hsum : (incrementWord (node ts).degrees).sum= -1 := by
      rw [degrees]
      change (incrementWord (ts.length::forestDegrees ts)).sum= -1
      simp only [incrementWord,List.map_cons,List.sum_cons]
      change (ts.length:ℤ)-1+(incrementWord (forestDegrees ts)).sum= -1
      rw [hs]; omega
    exact ⟨hsum,fun j hj => by
      cases j with
      | zero => simpa only [List.drop_zero,hsum] using (by norm_num : (-1:ℤ)<0)
      | succ j =>
        simpa only [degrees,List.drop_succ_cons,forestDegrees] using
          hn j (by simpa only [degrees,List.length_cons,Nat.succ_lt_succ_iff,forestDegrees] using hj)⟩

lemma degrees_excursion (t : PlaneTree) : IsExcursionList (incrementWord t.degrees) := by
  obtain ⟨hs,hn⟩ := degrees_properties t
  refine ⟨hs,fun j hj => ?_⟩
  have hneg := hn j (by simpa [incrementWord] using hj)
  have he : (incrementWord (t.degrees.drop j)).sum =
      (incrementWord t.degrees).sum-prefixSum (incrementWord t.degrees) j := by
    rw [incrementWord,List.map_drop,sum_drop]; rfl
  rw [he,hs] at hneg
  omega

lemma degrees_nonempty (t : PlaneTree) : t.degrees≠[] := by cases t; simp [degrees]

lemma mirror_degrees_perm (t : PlaneTree) : t.mirror.degrees.Perm t.degrees := by
  induction t using inductionMem with
  | hn ts ih =>
    simp only [mirror,degrees,List.length_map,List.length_reverse]
    apply List.Perm.cons
    rw [List.flatMap_map]
    exact (List.reverse_perm ts).flatMap (fun t ht => ih t (by simpa using ht))

lemma mirror_size (t : PlaneTree) : t.mirror.degrees.length=t.degrees.length :=
  t.mirror_degrees_perm.length_eq

lemma mirror_weight (w : ℕ → ℝ) (t : PlaneTree) :
    (t.mirror.degrees.map w).prod=(t.degrees.map w).prod :=
  (t.mirror_degrees_perm.map w).prod_eq

end PlaneTree
end FKCRT.TreeCoding
end


noncomputable section
open List
namespace FKCRT.Inventory
attribute [local instance] Classical.propDecidable

abbrev CoreLabel := Option Core
namespace CoreLabel

def arity : CoreLabel → ℕ
  | none => 0
  | some c => c.val.length

end CoreLabel

namespace CoreTree

def labels : CoreTree → List CoreLabel
  | leaf => [none]
  | branch c ts => some c::(List.ofFn (fun i => labels (ts i))).flatten

lemma labels_branch (c : Core) (ts : Fin c.val.length → CoreTree) :
    (branch c ts).labels=some c::(List.ofFn ts).flatMap labels := by
  simp [labels,List.flatMap_def,Function.comp_def]

def degrees (t : CoreTree) : List ℕ := t.labels.map CoreLabel.arity

def assemble (c : CoreLabel) (fs : List CoreTree) : CoreTree :=
  match c with
  | none => leaf
  | some c => branch c (fun i => fs[i.val]?.getD leaf)

def build : List CoreLabel → List CoreTree → List CoreTree
  | [],fs => fs
  | c::l,fs => let ts := build l fs; assemble c ts::ts.drop c.arity

lemma build_append (l l' : List CoreLabel) (fs : List CoreTree) :
    build (l++l') fs=build l (build l' fs) := by
  induction l with
  | nil => rfl
  | cons c l ih => simp only [List.cons_append,build,ih]

lemma build_labels (T : CoreTree) (fs : List CoreTree) : build T.labels fs=T::fs := by
  induction T generalizing fs with
  | leaf => simp [labels,build,assemble,CoreLabel.arity]
  | branch c ts ih =>
    have hf : ∀ (xs : List CoreTree), (∀ t∈xs,∀ fs,build t.labels fs=t::fs)  → 
        ∀ fs,build (xs.flatMap labels) fs=xs++fs := by
      intro xs hx fs
      induction xs with
      | nil => rfl
      | cons t xs ih' =>
        rw [List.flatMap_cons,build_append,ih' (by aesop),hx t (by simp)]
        rfl
    have he := hf (List.ofFn ts) (by
      intro t ht
      obtain ⟨i,rfl⟩ := List.mem_ofFn.mp ht
      exact ih i) fs
    rw [labels_branch,build,he]
    simp only [CoreLabel.arity,assemble]
    have ha : (fun i : Fin c.val.length => ((List.ofFn ts)++fs)[i.val]?.getD leaf)=ts := by
      funext i
      rw [List.getElem?_append_left (by simp),List.getElem?_eq_getElem (by simp)]
      simp
    rw [ha]
    simp

lemma labels_injective : Function.Injective labels := by
  intro T U h
  have hh := congrArg (fun l => build l []) h
  simpa only [build_labels,List.cons.injEq,and_true] using hh

lemma ofFn_getD_eq_take (fs : List CoreTree) {k : ℕ} (hk : k≤fs.length) :
    List.ofFn (fun i : Fin k => fs[i.val]?.getD leaf)=fs.take k := by
  apply List.ext_getElem
  · simp [Nat.min_eq_left hk]
  · intro i h1 h2
    have hi : i<k := by simpa using h1
    rw [List.getElem_ofFn,List.getElem_take]
    rw [List.getElem?_eq_getElem (hi.trans_le hk)]
    rfl

lemma assemble_labels (c : CoreLabel) (fs : List CoreTree) (hc : c.arity≤fs.length) :
    (assemble c fs).labels=c::(fs.take c.arity).flatMap labels := by
  cases c with
  | none => simp [assemble,labels,CoreLabel.arity]
  | some c =>
    simp only [assemble,labels_branch,CoreLabel.arity]
    exact congrArg (fun xs : List CoreTree => some c::xs.flatMap labels)
      (ofFn_getD_eq_take fs (k := c.val.length) hc)

lemma build_correct {l : List CoreLabel}
    (h : FKCRT.TreeCoding.PlaneTree.SuffixNegative (l.map CoreLabel.arity)) :
    (build l []).flatMap labels=l ∧
      ((build l []).length:ℤ)= -(FKCRT.TreeCoding.PlaneTree.incrementWord (l.map CoreLabel.arity)).sum := by
  induction l with
  | nil => simp [build,FKCRT.TreeCoding.PlaneTree.incrementWord]
  | cons c l ih =>
    obtain ⟨he,hlen⟩ := ih (FKCRT.TreeCoding.PlaneTree.suffixNegative_tail h)
    have hneg := h 0 (by simp)
    simp only [List.map_cons,List.drop_zero,FKCRT.TreeCoding.PlaneTree.incrementWord,List.sum_cons] at hneg
    have hk : c.arity≤(build l []).length := by
      unfold FKCRT.TreeCoding.PlaneTree.incrementWord at hlen
      omega
    constructor
    · simp only [build,List.flatMap_cons,assemble_labels c _ hk,List.cons_append]
      rw [← List.flatMap_append,List.take_append_drop,he]
    · simp only [build,List.length_cons,List.length_drop,List.map_cons,
        FKCRT.TreeCoding.PlaneTree.incrementWord,List.sum_cons]
      rw [Nat.cast_add,Nat.cast_sub hk]
      simp only [Nat.cast_one]
      unfold FKCRT.TreeCoding.PlaneTree.incrementWord at hlen
      omega

/-- The actual labelled arity excursion determines exactly one connected-core
ordered tree. No probabilistic independence is part of this statement. -/
theorem exists_of_excursion {l : List CoreLabel}
    (h : FKCRT.TreeCoding.IsExcursionList
      (FKCRT.TreeCoding.PlaneTree.incrementWord (l.map CoreLabel.arity))) :
    ∃ T : CoreTree,T.labels=l := by
  obtain ⟨he,hlen⟩ := build_correct (FKCRT.TreeCoding.PlaneTree.suffixNegative_of_excursion h)
  rw [h.1] at hlen
  have hl : (build l []).length=1 := by omega
  obtain ⟨T,hT⟩ := List.length_eq_one_iff.mp hl
  exact ⟨T,by simpa [hT] using he⟩

end CoreTree
end FKCRT.Inventory
end

end OAI