lean/OAI/SetTheory/PartitionPrinciple/Forcing/DenseInterpolation.lean

import OAI.SetTheory.PartitionPrinciple.Transfinite.HeightTower

namespace OAI

section

namespace PartitionPilot.Compression.RecursiveMaps

universe u v w

structure LinearHeightOrder (A : Type u) extends HeightOrder A where
  compare : ∀ x y, lt x y ∨ x = y ∨ lt y x

structure DenseHeightOrder (A : Type u) extends LinearHeightOrder A where
  between : ∀ x y, lt x y → ∃ z, lt x z ∧ lt z y

namespace LinearHeightOrder

variable {A : Type u} (R : LinearHeightOrder A)

theorem asymm {x y : A} (h : R.lt x y) : ¬ R.lt y x :=
  fun h' => R.irrefl x (R.trans h h')

theorem weak_refl (x : A) : R.Weak x x := Or.inl rfl

theorem weak_trans {x y z : A} (h : R.Weak x y) (h' : R.Weak y z) : R.Weak x z := by
  rcases h with rfl | h
  · exact h'
  · exact Or.inr (R.lt_weak h h')

theorem list_max (a : A) (xs : List A) :
    ∃ m, (m = a ∨ m ∈ xs) ∧ R.Weak a m ∧ ∀ x ∈ xs, R.Weak x m := by
  induction xs with
  | nil => exact ⟨a, Or.inl rfl, R.weak_refl a, by simp⟩
  | cons x xs ih =>
    rcases ih with ⟨m, hm, ha, hx⟩
    rcases R.compare x m with h | eq | h
    · refine ⟨m, ?_, ha, ?_⟩
      · rcases hm with hm | hm
        · exact Or.inl hm
        · exact Or.inr (List.mem_cons_of_mem x hm)
      · intro y hy
        rcases List.mem_cons.mp hy with rfl | hy
        · exact Or.inr h
        · exact hx y hy
    · refine ⟨m, ?_, ha, ?_⟩
      · exact Or.inr (List.mem_cons.mpr (Or.inl eq.symm))
      · intro y hy
        rcases List.mem_cons.mp hy with rfl | hy
        · exact Or.inl eq
        · exact hx y hy
    · refine ⟨x, Or.inr (List.mem_cons_self), R.weak_trans ha (Or.inr h), ?_⟩
      intro y hy
      rcases List.mem_cons.mp hy with rfl | hy
      · exact R.weak_refl _
      · exact R.weak_trans (hx y hy) (Or.inr h)

def reverse : LinearHeightOrder A where
  lt x y := R.lt y x
  irrefl := R.irrefl
  trans h h' := R.trans h' h
  compare x y := by
    rcases R.compare y x with h | eq | h
    · exact Or.inl h
    · exact Or.inr (Or.inl eq.symm)
    · exact Or.inr (Or.inr h)

theorem list_min (a : A) (xs : List A) :
    ∃ m, (m = a ∨ m ∈ xs) ∧ R.Weak m a ∧ ∀ x ∈ xs, R.Weak m x := by
  rcases R.reverse.list_max a xs with ⟨m, hm, ha, hx⟩
  refine ⟨m, hm, ?_, ?_⟩
  · rcases ha with eq | h
    · exact Or.inl eq.symm
    · exact Or.inr h
  · intro x h
    rcases hx x h with eq | h'
    · exact Or.inl eq.symm
    · exact Or.inr h'

end LinearHeightOrder

namespace DenseHeightOrder

variable {D : Type v} (R : DenseHeightOrder D)

theorem finite_gap (lo hi : D) (lower upper : List D)
    (gap : R.lt lo hi)
    (lower_hi : ∀ x ∈ lower, R.lt x hi)
    (lo_upper : ∀ y ∈ upper, R.lt lo y)
    (separated : ∀ x ∈ lower, ∀ y ∈ upper, R.lt x y) :
    ∃ z, R.lt lo z ∧ R.lt z hi ∧
      (∀ x ∈ lower, R.lt x z) ∧ (∀ y ∈ upper, R.lt z y) := by
  rcases R.toLinearHeightOrder.list_max lo lower with ⟨a, ha, hlo, hlow⟩
  rcases R.toLinearHeightOrder.list_min hi upper with ⟨b, hb, hhi, hupp⟩
  have ab : R.lt a b := by
    rcases ha with rfl | ha
    · rcases hb with rfl | hb
      · exact gap
      · exact lo_upper b hb
    · rcases hb with rfl | hb
      · exact lower_hi a ha
      · exact separated a ha b hb
  rcases R.between a b ab with ⟨z, az, zb⟩
  exact ⟨z, R.weak_lt hlo az, R.lt_weak zb hhi,
    fun x hx => R.weak_lt (hlow x hx) az,
    fun y hy => R.lt_weak zb (hupp y hy)⟩

end DenseHeightOrder

namespace CountableInterpolation

variable {A : Type u} {D : Type v} (S : LinearHeightOrder A)
    (R : DenseHeightOrder D) (enumerate : Nat → A) (lo hi : D)

structure Partial (n : Nat) where
  value : Nat → D
  lower : ∀ i, i < n → R.lt lo (value i)
  upper : ∀ i, i < n → R.lt (value i) hi
  strict : ∀ i j, i < n → j < n → S.lt (enumerate i) (enumerate j) → R.lt (value i) (value j)
  equal : ∀ i j, i < n → j < n → enumerate i = enumerate j → value i = value j

variable {S R enumerate lo hi}

theorem next_exists {n : Nat} (p : Partial S R enumerate lo hi n) (gap : R.lt lo hi) :
    ∃ z, R.lt lo z ∧ R.lt z hi ∧
      (∀ i, i < n → S.lt (enumerate i) (enumerate n) → R.lt (p.value i) z) ∧
      (∀ i, i < n → S.lt (enumerate n) (enumerate i) → R.lt z (p.value i)) ∧
      (∀ i, i < n → enumerate i = enumerate n → p.value i = z) := by
  classical
  by_cases seen : ∃ i, i < n ∧ enumerate i = enumerate n
  · rcases seen with ⟨j, hj, he⟩
    refine ⟨p.value j, p.lower j hj, p.upper j hj, ?_, ?_, ?_⟩
    · intro i h h'
      exact p.strict i j h hj (he ▸ h')
    · intro i h h'
      exact p.strict j i hj h (he ▸ h')
    · intro i h h'
      exact p.equal i j h hj (h'.trans he.symm)
  · let lowers := ((List.range n).filter (fun i => S.lt (enumerate i) (enumerate n))).map p.value
    let uppers := ((List.range n).filter (fun i => S.lt (enumerate n) (enumerate i))).map p.value
    have lower_spec : ∀ x, x ∈ lowers ↔ ∃ i, i < n ∧ S.lt (enumerate i) (enumerate n) ∧ p.value i = x := by
      intro x
      simp only [lowers, List.mem_map, List.mem_filter, List.mem_range, decide_eq_true_eq]
      constructor
      · rintro ⟨i, ⟨h, h'⟩, eq⟩
        exact ⟨i, h, h', eq⟩
      · rintro ⟨i, h, h', eq⟩
        exact ⟨i, ⟨h, h'⟩, eq⟩
    have upper_spec : ∀ x, x ∈ uppers ↔ ∃ i, i < n ∧ S.lt (enumerate n) (enumerate i) ∧ p.value i = x := by
      intro x
      simp only [uppers, List.mem_map, List.mem_filter, List.mem_range, decide_eq_true_eq]
      constructor
      · rintro ⟨i, ⟨h, h'⟩, eq⟩
        exact ⟨i, h, h', eq⟩
      · rintro ⟨i, h, h', eq⟩
        exact ⟨i, ⟨h, h'⟩, eq⟩
    have lh : ∀ x ∈ lowers, R.lt x hi := by
      intro x hx
      rcases (lower_spec x).mp hx with ⟨i, h, _, rfl⟩
      exact p.upper i h
    have lu : ∀ x ∈ uppers, R.lt lo x := by
      intro x hx
      rcases (upper_spec x).mp hx with ⟨i, h, _, rfl⟩
      exact p.lower i h
    have sep : ∀ x ∈ lowers, ∀ y ∈ uppers, R.lt x y := by
      intro x hx y hy
      rcases (lower_spec x).mp hx with ⟨i, h, h', rfl⟩
      rcases (upper_spec y).mp hy with ⟨j, k, k', rfl⟩
      exact p.strict i j h k (S.trans h' k')
    rcases R.finite_gap lo hi lowers uppers gap lh lu sep with ⟨z, hz, zh, hl, hu⟩
    refine ⟨z, hz, zh, ?_, ?_, ?_⟩
    · intro i h h'
      exact hl _ ((lower_spec _).mpr ⟨i, h, h', rfl⟩)
    · intro i h h'
      exact hu _ ((upper_spec _).mpr ⟨i, h, h', rfl⟩)
    · intro i h eq
      exact False.elim (seen ⟨i, h, eq⟩)

noncomputable def nextPoint {n : Nat} (p : Partial S R enumerate lo hi n) (gap : R.lt lo hi) : D :=
  Classical.choose (next_exists p gap)

theorem nextPoint_spec {n : Nat} (p : Partial S R enumerate lo hi n) (gap : R.lt lo hi) :
    R.lt lo (nextPoint p gap) ∧ R.lt (nextPoint p gap) hi ∧
      (∀ i, i < n → S.lt (enumerate i) (enumerate n) → R.lt (p.value i) (nextPoint p gap)) ∧
      (∀ i, i < n → S.lt (enumerate n) (enumerate i) → R.lt (nextPoint p gap) (p.value i)) ∧
      (∀ i, i < n → enumerate i = enumerate n → p.value i = nextPoint p gap) :=
  Classical.choose_spec (next_exists p gap)

noncomputable def extend {n : Nat} (p : Partial S R enumerate lo hi n) (gap : R.lt lo hi) :
    Partial S R enumerate lo hi (n + 1) where
  value i := if i < n then p.value i else nextPoint p gap
  lower i _ := by
    split
    · exact p.lower i ‹i < n›
    · exact (nextPoint_spec p gap).1
  upper i _ := by
    split
    · exact p.upper i ‹i < n›
    · exact (nextPoint_spec p gap).2.1
  strict i j h k lt := by
    split <;> split
    · exact p.strict i j ‹i < n› ‹j < n› lt
    · have eq : j = n := by omega
      subst j
      exact (nextPoint_spec p gap).2.2.1 i ‹i < n› lt
    · have eq : i = n := by omega
      subst i
      exact (nextPoint_spec p gap).2.2.2.1 j ‹j < n› lt
    · have ei : i = n := by omega
      have ej : j = n := by omega
      subst i
      subst j
      exact False.elim (S.irrefl _ lt)
  equal i j h k eq := by
    split <;> split
    · exact p.equal i j ‹i < n› ‹j < n› eq
    · have ej : j = n := by omega
      subst j
      exact (nextPoint_spec p gap).2.2.2.2 i ‹i < n› eq
    · have ei : i = n := by omega
      subst i
      exact ((nextPoint_spec p gap).2.2.2.2 j ‹j < n› eq.symm).symm
    · rfl

noncomputable def stages (gap : R.lt lo hi) : (n : Nat) → Partial S R enumerate lo hi n
  | 0 => {
      value := fun _ => lo
      lower := fun _ h => False.elim (Nat.not_lt_zero _ h)
      upper := fun _ h => False.elim (Nat.not_lt_zero _ h)
      strict := fun _ _ h _ _ => False.elim (Nat.not_lt_zero _ h)
      equal := fun _ _ h _ _ => False.elim (Nat.not_lt_zero _ h) }
  | n + 1 => extend (stages gap n) gap

theorem stages_step (gap : R.lt lo hi) (n i : Nat) (h : i < n) :
    (stages (S := S) (enumerate := enumerate) gap (n + 1)).value i =
      (stages (S := S) (enumerate := enumerate) gap n).value i := by
  exact ite_eq_left h

noncomputable def value (gap : R.lt lo hi) (i : Nat) : D :=
  (stages (S := S) (enumerate := enumerate) gap (i + 1)).value i

theorem restriction (gap : R.lt lo hi) (n i : Nat) (h : i < n) :
    (stages (S := S) (enumerate := enumerate) gap n).value i =
      value (S := S) (enumerate := enumerate) gap i := by
  induction n with
  | zero => omega
  | succ n ih =>
    by_cases eq : i = n
    · subst i
      rfl
    · have hn : i < n := by omega
      exact (stages_step (S := S) (enumerate := enumerate) gap n i hn).trans (ih hn)

theorem value_lower (gap : R.lt lo hi) (i : Nat) :
    R.lt lo (value (S := S) (enumerate := enumerate) gap i) :=
  (stages gap (i + 1)).lower i (Nat.lt_succ_self i)

theorem value_upper (gap : R.lt lo hi) (i : Nat) :
    R.lt (value (S := S) (enumerate := enumerate) gap i) hi :=
  (stages gap (i + 1)).upper i (Nat.lt_succ_self i)

theorem value_strict (gap : R.lt lo hi) (i j : Nat) (lt : S.lt (enumerate i) (enumerate j)) :
    R.lt (value (S := S) (enumerate := enumerate) gap i)
      (value (S := S) (enumerate := enumerate) gap j) := by
  have hi : i < i + j + 1 := by omega
  have hj : j < i + j + 1 := by omega
  have h := (stages gap (i + j + 1)).strict i j hi hj lt
  rw [restriction gap _ i hi, restriction gap _ j hj] at h
  exact h

theorem value_equal (gap : R.lt lo hi) (i j : Nat) (eq : enumerate i = enumerate j) :
    value (S := S) (enumerate := enumerate) gap i =
      value (S := S) (enumerate := enumerate) gap j := by
  have hi : i < i + j + 1 := by omega
  have hj : j < i + j + 1 := by omega
  have h := (stages (S := S) gap (i + j + 1)).equal i j hi hj eq
  rw [restriction gap _ i hi, restriction gap _ j hj] at h
  exact h

end CountableInterpolation

theorem countable_range_interpolation {X : Type u} {H : Type v} {D : Type w}
    (S : LinearHeightOrder H) (R : DenseHeightOrder D) (height : X → H)
    (base : X) (countable : CountableRange height) (lo hi : D) (gap : R.lt lo hi) :
    ∃ assign : X → D, (∀ x, R.lt lo (assign x) ∧ R.lt (assign x) hi) ∧
      (∀ x y, S.lt (height x) (height y) → R.lt (assign x) (assign y)) ∧
      (∀ x y, height x = height y → assign x = assign y) := by
  classical
  rcases countable with ⟨code, code_equal⟩
  let enumerate : Nat → H := fun n =>
    if h : ∃ x, code x = n then height (Classical.choose h) else height base
  have cover : ∀ x, enumerate (code x) = height x := by
    intro x
    have h : ∃ y, code y = code x := ⟨x, rfl⟩
    dsimp [enumerate]
    rw [dite_eq_left h]
    exact code_equal _ x (Classical.choose_spec h)
  refine ⟨fun x => CountableInterpolation.value (S := S) (enumerate := enumerate) gap (code x), ?_, ?_, ?_⟩
  · intro x
    exact ⟨CountableInterpolation.value_lower gap _, CountableInterpolation.value_upper gap _⟩
  · intro x y lt
    apply CountableInterpolation.value_strict
    rw [cover, cover]
    exact lt
  · intro x y eq
    apply CountableInterpolation.value_equal
    rw [cover, cover]
    exact eq

end PartitionPilot.Compression.RecursiveMaps

end

end OAI