lean/OAI/Probability/FreeIsing/Trees/ConeCoding.lean

import OAI.Probability.FreeIsing.Trees.ConnectedHull
import OAI.Probability.FreeIsing.Trees.Parents

namespace OAI

noncomputable section

open MeasureTheory

namespace Problem367.TreeConeCoding

def encode {b : ℕ} (c : Fin (b + 1)) : List (Fin b) → List (Fin (b + 1))
  | [] => []
  | i :: w => (finSuccAboveEquiv c i).1 :: encode (finSuccAboveEquiv c i).1 w

@[simp] theorem encode_nil {b : ℕ} (c : Fin (b + 1)) : encode c [] = [] := rfl

@[simp] theorem length_encode {b : ℕ} (c : Fin (b + 1)) (w : List (Fin b)) :
    (encode c w).length = w.length := by
  induction w generalizing c with
  | nil => rfl
  | cons i w ih => simp only [encode, List.length_cons, ih]

theorem chain_encode {b : ℕ} (c : Fin (b + 1)) (w : List (Fin b)) :
    List.IsChain (fun a b => a ≠ b) (c :: encode c w) := by
  induction w generalizing c with
  | nil => exact List.IsChain.singleton c
  | cons i w ih =>
      exact List.isChain_cons_cons.mpr ⟨(finSuccAboveEquiv c i).2.symm, ih _⟩

theorem encode_injective {b : ℕ} (c : Fin (b + 1)) : Function.Injective (encode c) := by
  intro x
  induction x generalizing c with
  | nil =>
      intro y h
      have := congrArg List.length h
      simpa only [length_encode, List.length_nil, eq_comm, List.length_eq_zero_iff] using this
  | cons i x ih =>
      intro y h
      cases y with
      | nil => have := congrArg List.length h; simp at this
      | cons j y =>
          have he := List.cons.inj h
          have hij : i = j := (finSuccAboveEquiv c).injective (Subtype.ext he.1)
          subst j
          exact congrArg (List.cons i) (ih _ he.2)

theorem encode_surjective {b : ℕ} (c : Fin (b + 1))
    (w : List (Fin (b + 1))) (hw : List.IsChain (fun a b => a ≠ b) (c :: w)) :
    ∃ x : List (Fin b), encode c x = w := by
  induction w generalizing c with
  | nil => exact ⟨[], rfl⟩
  | cons a w ih =>
      obtain ⟨hca, haw⟩ := List.isChain_cons_cons.mp hw
      obtain ⟨x, hx⟩ := ih a haw
      let i := (finSuccAboveEquiv c).symm ⟨a, hca.symm⟩
      have hi : (finSuccAboveEquiv c i).1 = a := by
        simp only [i, Equiv.apply_symm_apply]
      refine ⟨i :: x, ?_⟩
      simp only [encode, hi, hx]

def continuationEquiv {b : ℕ} (c : Fin (b + 1)) :
    List (Fin b) ≃ {w : List (Fin (b + 1)) // List.IsChain (fun a b => a ≠ b) (c :: w)} :=
  Equiv.ofBijective (fun x => ⟨encode c x, chain_encode c x⟩)
    ⟨fun _ _ h => encode_injective c (congrArg Subtype.val h), by
      rintro ⟨w, hw⟩
      obtain ⟨x, hx⟩ := encode_surjective c w hw
      exact ⟨x, Subtype.ext hx⟩⟩

@[simp] theorem encode_take {b : ℕ} (c : Fin (b + 1)) (w : List (Fin b)) (n : ℕ) :
    encode c (w.take n) = (encode c w).take n := by
  induction n generalizing c w with
  | zero => simp
  | succ n ih =>
      cases w with
      | nil => rfl
      | cons i w => simp only [List.take_succ_cons, encode, ih]

theorem chain_append_iff {α : Type*} (R : α → α → Prop) (r w : List α) (hr : r ≠ []) :
    List.IsChain R (r ++ w) ↔ List.IsChain R r ∧ List.IsChain R (r.getLast hr :: w) := by
  conv_lhs => rw [← List.dropLast_append_getLast hr]
  simp only [List.append_assoc, List.singleton_append]
  rw [List.isChain_split, List.dropLast_append_getLast]

def vertex {b : ℕ} (r : TreeVertex (b + 1)) (hr : r.1 ≠ [])
    (w : List (Fin b)) : TreeVertex (b + 1) :=
  ⟨r.1 ++ encode (r.1.getLast hr) w,
    (chain_append_iff _ _ _ hr).mpr ⟨r.2, chain_encode _ _⟩⟩

@[simp] theorem vertex_val {b : ℕ} (r : TreeVertex (b + 1)) (hr : r.1 ≠ [])
    (w : List (Fin b)) :
    (vertex r hr w).1 = r.1 ++ encode (r.1.getLast hr) w := rfl

@[simp] theorem vertex_nil {b : ℕ} (r : TreeVertex (b + 1)) (hr : r.1 ≠ []) :
    vertex r hr [] = r := by
  apply Subtype.ext
  simp

@[simp] theorem length_vertex {b : ℕ} (r : TreeVertex (b + 1)) (hr : r.1 ≠ [])
    (w : List (Fin b)) : (vertex r hr w).1.length = r.1.length + w.length := by
  simp

theorem vertex_prefix {b : ℕ} (r : TreeVertex (b + 1)) (hr : r.1 ≠ [])
    (w : List (Fin b)) : r.1 <+: (vertex r hr w).1 := List.prefix_append _ _

theorem vertex_injective {b : ℕ} (r : TreeVertex (b + 1)) (hr : r.1 ≠ []) :
    Function.Injective (vertex r hr) := by
  intro x y h
  apply encode_injective (r.1.getLast hr)
  exact List.append_cancel_left (congrArg Subtype.val h)

theorem vertex_surjective_cone {b : ℕ} (r : TreeVertex (b + 1)) (hr : r.1 ≠ [])
    (v : TreeVertex (b + 1)) (hv : r.1 <+: v.1) :
    ∃ w : List (Fin b), vertex r hr w = v := by
  obtain ⟨tail, htail⟩ := hv
  have hc : List.IsChain (fun a b => a ≠ b) (r.1.getLast hr :: tail) := by
    apply ((chain_append_iff _ _ _ hr).mp _).2
    rw [htail]
    exact v.2
  obtain ⟨w, hw⟩ := encode_surjective (r.1.getLast hr) tail hc
  refine ⟨w, Subtype.ext ?_⟩
  change r.1 ++ encode (r.1.getLast hr) w = v.1
  rw [hw, htail]

def coneEquiv {b : ℕ} (r : TreeVertex (b + 1)) (hr : r.1 ≠ []) :
    List (Fin b) ≃ {v : TreeVertex (b + 1) // r.1 <+: v.1} :=
  Equiv.ofBijective (fun w => ⟨vertex r hr w, vertex_prefix r hr w⟩)
    ⟨fun _ _ h => vertex_injective r hr (congrArg Subtype.val h), by
      rintro ⟨v, hv⟩
      obtain ⟨w, hw⟩ := vertex_surjective_cone r hr v hv
      exact ⟨w, Subtype.ext hw⟩⟩

theorem vertex_take {b : ℕ} (r : TreeVertex (b + 1)) (hr : r.1 ≠ [])
    (w : List (Fin b)) (n : ℕ) :
    vertex r hr (w.take n) =
      ConnectedHull.takeVertex (vertex r hr w) (r.1.length + n) := by
  apply Subtype.ext
  change r.1 ++ encode (r.1.getLast hr) (w.take n) =
    (r.1 ++ encode (r.1.getLast hr) w).take (r.1.length + n)
  rw [List.take_length_add_append, encode_take]

def labels {b : ℕ} {A : Type*} (r : TreeVertex (b + 1)) (hr : r.1 ≠ [])
    (U : TreeVertex (b + 1) → A) : List (Fin b) → A :=
  fun w => U (vertex r hr w)

theorem measurable_labels {b : ℕ} {A : Type*} [MeasurableSpace A]
    (r : TreeVertex (b + 1)) (hr : r.1 ≠ []) :
    Measurable (labels (A := A) r hr) :=
  Measurable.of_eval (fun _ => measurable_pi_apply _)

theorem map_labels {b : ℕ} {A : Type*} [MeasurableSpace A]
    (ν : Measure A) [IsProbabilityMeasure ν]
    (r : TreeVertex (b + 1)) (hr : r.1 ≠ []) :
    Measure.map (labels r hr) (Measure.infinitePi (fun _ : TreeVertex (b + 1) => ν)) =
      Measure.infinitePi (fun _ : List (Fin b) => ν) := by
  exact Measure.map_infinitePi_infinitePi_of_inj (vertex_injective r hr)

theorem measurePreserving_labels {b : ℕ} {A : Type*} [MeasurableSpace A]
    (ν : Measure A) [IsProbabilityMeasure ν]
    (r : TreeVertex (b + 1)) (hr : r.1 ≠ []) :
    MeasurePreserving (labels r hr)
      (Measure.infinitePi (fun _ : TreeVertex (b + 1) => ν))
      (Measure.infinitePi (fun _ : List (Fin b) => ν)) :=
  ⟨measurable_labels r hr, map_labels ν r hr⟩

theorem map_uniform_labels {b : ℕ}
    (r : TreeVertex (b + 1)) (hr : r.1 ≠ []) :
    Measure.map (labels r hr) (labelMeasure (b + 1)) =
      Measure.infinitePi (fun _ : List (Fin b) => uniform01) :=
  map_labels uniform01 r hr

end Problem367.TreeConeCoding

end

end OAI