import OAI.SetTheory.PartitionPrinciple.Transfinite.AttachmentCoinitiality

namespace OAI

section

namespace PartitionPilot.Compression.RecursiveMaps.PrincipalAmalgamation

open Attachment

universe u v

structure Input {A : Type u} {B : Type v} (P : MeetOrder A) (Q : MeetOrder B) where
  leftAnchor : A
  rightAnchor : B
  overlap : MeetIso (idealOrder Q rightAnchor) (idealOrder P leftAnchor)

namespace Input

variable {A : Type u} {B : Type v} {P : MeetOrder A} {Q : MeetOrder B} (g : Input P Q)

def Fresh := {b : B // ¬ Q.le b g.rightAnchor}

def Node := A ⊕ g.Fresh

def shadow (b : B) : A := (g.overlap.toFun (cut Q g.rightAnchor b)).val

theorem shadow_le_anchor (b : B) : P.le (g.shadow b) g.leftAnchor :=
  (g.overlap.toFun (cut Q g.rightAnchor b)).property

theorem shadow_mono {b c : B} (h : Q.le b c) : P.le (g.shadow b) (g.shadow c) :=
  (g.overlap.le_iff _ _).mpr (cut_mono Q g.rightAnchor h)

theorem shadow_meet (b c : B) : g.shadow (Q.meet b c) = P.meet (g.shadow b) (g.shadow c) := by
  unfold shadow
  rw [cut_meet, g.overlap.map_meet]
  rfl

def data : Data P g.Fresh Unit where
  component _ := ()
  base _ := g.leftAnchor
  upper _ _ := False
  upper_up := by intro _ _ _ h _; exact h
  upper_meet := by intro _ _ _ h _; exact h
  base_le_upper _ _ h := False.elim h
  base_not_upper _ h := h
  shadow x := g.shadow x.val
  shadow_le_base x := g.shadow_le_anchor x.val
  inside x y := Q.le x.val y.val
  inside_refl x := Q.refl x.val
  inside_trans := Q.trans
  inside_antisymm hxy hyx := Subtype.ext (Q.antisymm hxy hyx)
  inside_component _ := rfl
  inside_shadow := g.shadow_mono

theorem component_meets : ComponentMeets g.data := by
  classical
  intro x y _
  by_cases old : Q.le (Q.meet x.val y.val) g.rightAnchor
  · exact Or.inr (fun z hx hy => z.property (Q.trans (Q.le_meet hx hy) old))
  · exact Or.inl ⟨⟨Q.meet x.val y.val, old⟩, Q.meet_le_left _ _, Q.meet_le_right _ _,
      fun _ hx hy => Q.le_meet hx hy, g.shadow_meet x.val y.val⟩

noncomputable def order : MeetOrder g.Node := meetOrder g.data g.component_meets

noncomputable def left : MeetEmbedding P g.order := oldEmbedding g.data g.component_meets

noncomputable def represent (b : B) : g.Node := by
  classical
  exact if h : Q.le b g.rightAnchor then .inl (g.overlap.toFun ⟨b, h⟩).val
    else .inr ⟨b, h⟩

theorem represent_old (b : B) (h : Q.le b g.rightAnchor) :
    g.represent b = .inl (g.overlap.toFun ⟨b, h⟩).val := by
  unfold represent
  exact dite_eq_left h

theorem represent_new (b : B) (h : ¬ Q.le b g.rightAnchor) :
    g.represent b = .inr ⟨b, h⟩ := by
  unfold represent
  exact dite_eq_right h

theorem represent_le_iff (b c : B) : g.order.le (g.represent b) (g.represent c) ↔ Q.le b c := by
  classical
  by_cases hb : Q.le b g.rightAnchor
  · rw [g.represent_old b hb]
    by_cases hc : Q.le c g.rightAnchor
    · rw [g.represent_old c hc]
      exact g.overlap.le_iff _ _
    · rw [g.represent_new c hc]
      change P.le (g.overlap.toFun ⟨b, hb⟩).val (g.overlap.toFun (cut Q g.rightAnchor c)).val ↔ _
      change (idealOrder P g.leftAnchor).le (g.overlap.toFun ⟨b, hb⟩)
        (g.overlap.toFun (cut Q g.rightAnchor c)) ↔ _
      rw [g.overlap.le_iff]
      exact ⟨fun h => Q.trans h (Q.meet_le_left _ _), fun h => Q.le_meet h hb⟩
  · rw [g.represent_new b hb]
    by_cases hc : Q.le c g.rightAnchor
    · rw [g.represent_old c hc]
      exact ⟨False.elim, fun h => hb (Q.trans h hc)⟩
    · rw [g.represent_new c hc]
      exact ⟨fun h => h.elim id False.elim, Or.inl⟩

theorem old_below_represent (a : A) (b : B) :
    g.order.le (.inl a) (g.represent b) ↔ P.le a (g.shadow b) := by
  classical
  by_cases h : Q.le b g.rightAnchor
  · rw [g.represent_old b h]
    unfold shadow
    rw [cut_of_le Q g.rightAnchor b h]
    exact Iff.rfl
  · rw [g.represent_new b h]
    exact Iff.rfl

theorem represented_meet (b c : B) :
    IsMeet g.data (g.represent b) (g.represent c) (g.represent (Q.meet b c)) := by
  refine ⟨(g.represent_le_iff _ _).mpr (Q.meet_le_left _ _),
    (g.represent_le_iff _ _).mpr (Q.meet_le_right _ _), ?_⟩
  intro x hx hy
  cases x with
  | inl a =>
    apply (g.old_below_represent a _).mpr
    rw [g.shadow_meet]
    exact P.le_meet ((g.old_below_represent a b).mp hx) ((g.old_below_represent a c).mp hy)
  | inr x =>
    have represented : g.represent x.val = Sum.inr x := g.represent_new x.val x.property
    rw [← represented] at hx hy ⊢
    exact (g.represent_le_iff _ _).mpr
      (Q.le_meet ((g.represent_le_iff _ _).mp hx) ((g.represent_le_iff _ _).mp hy))

noncomputable def right : MeetEmbedding Q g.order where
  toFun := g.represent
  le_iff := g.represent_le_iff
  map_meet b c := (meet_eq g.data g.component_meets (g.represented_meet b c)).symm

theorem cover (x : g.Node) : (∃ a, g.left.toFun a = x) ∨ (∃ b, g.right.toFun b = x) := by
  cases x with
  | inl a => exact Or.inl ⟨a, rfl⟩
  | inr b => exact Or.inr ⟨b.val, g.represent_new b.val b.property⟩

theorem left_ideal (a : A) (x : g.Node) (h : g.order.le x (g.left.toFun a)) :
    ∃ b, g.left.toFun b = x := by
  cases x with
  | inl b => exact ⟨b, rfl⟩
  | inr x => exact False.elim h

theorem overlap_exact (a : A) (b : B) :
    g.right.toFun b = g.left.toFun a ↔
      ∃ h : Q.le b g.rightAnchor, (g.overlap.toFun ⟨b, h⟩).val = a := by
  classical
  change g.represent b = Sum.inl a ↔ _
  by_cases h : Q.le b g.rightAnchor
  · rw [g.represent_old b h]
    constructor
    · intro eq
      exact ⟨h, Sum.inl.inj eq⟩
    · rintro ⟨_, eq⟩
      exact congrArg Sum.inl eq
  · rw [g.represent_new b h]
    exact ⟨(fun eq => by cases eq), fun ⟨hb, _⟩ => False.elim (h hb)⟩

theorem old_in_right (a : A) :
    (∃ b, g.right.toFun b = g.left.toFun a) ↔ P.le a g.leftAnchor := by
  constructor
  · rintro ⟨b, eq⟩
    rcases (g.overlap_exact a b).mp eq with ⟨hb, val⟩
    exact val ▸ (g.overlap.toFun ⟨b, hb⟩).property
  · intro ha
    let b := g.overlap.inverse ⟨a, ha⟩
    refine ⟨b.val, (g.overlap_exact a b.val).mpr ⟨b.property, ?_⟩⟩
    exact congrArg Subtype.val (g.overlap.right_inverse ⟨a, ha⟩)

theorem right_ideal (b : B) (x : g.Node) (h : g.order.le x (g.right.toFun b)) :
    ∃ c, g.right.toFun c = x := by
  cases x with
  | inl a =>
    apply (g.old_in_right a).mpr
    exact P.trans ((g.old_below_represent a b).mp h) (g.shadow_le_anchor b)
  | inr x => exact ⟨x.val, g.represent_new x.val x.property⟩

theorem cross_meet (a : A) (b : B) :
    g.order.meet (g.left.toFun a) (g.right.toFun b) = .inl (P.meet a (g.shadow b)) := by
  apply meet_eq g.data g.component_meets
  refine ⟨P.meet_le_left _ _, (g.old_below_represent _ b).mpr (P.meet_le_right _ _), ?_⟩
  intro x hx hy
  rcases g.left_ideal a x hx with ⟨c, rfl⟩
  exact P.le_meet hx ((g.old_below_represent c b).mp hy)

theorem new_shadow_meet (b : g.Fresh) (a : A) :
    g.order.meet (.inr b) (.inl a) = .inl (P.meet (g.shadow b.val) a) :=
  meet_eq g.data g.component_meets (Attachment.shadow_meet g.data b a (fun h => h))

theorem principal_cross_meet (a : A) (b : B) :
    g.order.meet (g.left.toFun a) (g.right.toFun b) =
      g.left.toFun (P.meet (P.meet a g.leftAnchor) (g.shadow b)) := by
  rw [g.cross_meet]
  apply congrArg Sum.inl
  apply P.antisymm
  · exact P.le_meet
      (P.le_meet (P.meet_le_left _ _)
        (P.trans (P.meet_le_right _ _) (g.shadow_le_anchor b)))
      (P.meet_le_right _ _)
  · exact P.le_meet
      (P.trans (P.meet_le_left _ _) (P.meet_le_left _ _)) (P.meet_le_right _ _)

theorem greatest_old_part (b : B) :
    ∀ a, g.order.le (g.left.toFun a) (g.right.toFun b) ↔ P.le a (g.shadow b) :=
  fun a => g.old_below_represent a b

theorem left_principal (top : A) (greatest : ∀ a, P.le a top) (x : g.Node) :
    g.order.le x (g.left.toFun top) ↔ ∃ a, g.left.toFun a = x := by
  constructor
  · exact g.left_ideal top x
  · rintro ⟨a, rfl⟩
    exact (g.left.le_iff _ _).mpr (greatest a)

theorem right_principal (top : B) (greatest : ∀ b, Q.le b top) (x : g.Node) :
    g.order.le x (g.right.toFun top) ↔ ∃ b, g.right.toFun b = x := by
  constructor
  · exact g.right_ideal top x
  · rintro ⟨b, rfl⟩
    exact (g.right.le_iff _ _).mpr (greatest b)

theorem least_preserved (zero : A) (least : ∀ a, P.le zero a) :
    ∀ x, g.order.le (g.left.toFun zero) x := by
  intro x
  cases x with
  | inl a => exact least a
  | inr b => exact least (g.shadow b.val)

theorem bottoms_agree (zeroA : A) (zeroB : B)
    (leastA : ∀ a, P.le zeroA a) (leastB : ∀ b, Q.le zeroB b) :
    g.right.toFun zeroB = g.left.toFun zeroA := by
  have lower := g.least_preserved zeroA leastA (g.right.toFun zeroB)
  rcases g.right_ideal zeroB (g.left.toFun zeroA) lower with ⟨b, eq⟩
  apply g.order.antisymm
  · rw [← eq]
    exact (g.right.le_iff _ _).mpr (leastB b)
  · exact lower

theorem comparison_in_vertex (x y : g.Node) (lower : g.order.le x y) :
    (∃ a b, g.left.toFun a = x ∧ g.left.toFun b = y ∧ P.le a b) ∨
    (∃ a b, g.right.toFun a = x ∧ g.right.toFun b = y ∧ Q.le a b) := by
  rcases g.cover y with ⟨b, rfl⟩ | ⟨b, rfl⟩
  · rcases g.left_ideal b x lower with ⟨a, rfl⟩
    exact Or.inl ⟨a, b, rfl, rfl, (g.left.le_iff _ _).mp lower⟩
  · rcases g.right_ideal b x lower with ⟨a, rfl⟩
    exact Or.inr ⟨a, b, rfl, rfl, (g.right.le_iff _ _).mp lower⟩

end Input

end PartitionPilot.Compression.RecursiveMaps.PrincipalAmalgamation



namespace PartitionPilot.Compression.RecursiveMaps.BinaryTiles

open Attachment PrincipalAmalgamation

universe u

variable {A : Type u} (P : MeetOrder A)

noncomputable def vertex (g : Input P P) : Bool → MeetEmbedding P g.order
  | false => g.left
  | true => g.right

theorem vertex_cover (g : Input P P) (x : g.Node) :
    ∃ i y, (vertex P g i).toFun y = x := by
  rcases g.cover x with ⟨y, eq⟩ | ⟨y, eq⟩
  · exact ⟨false, y, eq⟩
  · exact ⟨true, y, eq⟩

def separation (W : A) : Input P P where
  leftAnchor := W
  rightAnchor := W
  overlap :=
    { toFun := id
      le_iff := fun _ _ => Iff.rfl
      map_meet := fun _ _ => rfl
      inverse := id
      left_inverse := fun _ => rfl
      right_inverse := fun _ => rfl }

theorem separation_fixes (W x : A) (below : P.le x W) :
    (separation P W).right.toFun x = (separation P W).left.toFun x :=
  (separation P W).represent_old x below

theorem separation_intersection (W x : A) :
    (∃ y, (separation P W).right.toFun y = (separation P W).left.toFun x) ↔ P.le x W :=
  (separation P W).old_in_right x

theorem separation_cross_meet (W D X : A) (belowD : P.le W D) (belowX : P.le W X) :
    (separation P W).order.meet ((separation P W).right.toFun D)
      ((separation P W).left.toFun X) = (separation P W).left.toFun W := by
  rw [meet_comm, (separation P W).cross_meet]
  change Sum.inl (P.meet X (P.meet D W)) = Sum.inl W
  have dw : P.meet D W = W :=
    P.antisymm (P.meet_le_right _ _) (P.le_meet belowD (P.refl W))
  have xw : P.meet X W = W :=
    P.antisymm (P.meet_le_right _ _) (P.le_meet belowX (P.refl W))
  rw [dw, xw]

def compression (T K : A) (top : ∀ x, P.le x T) (S : MeetIso P (idealOrder P K)) :
    Input P P where
  leftAnchor := K
  rightAnchor := T
  overlap :=
    { toFun := fun x => S.toFun x.val
      le_iff := fun x y => S.le_iff x.val y.val
      map_meet := fun x y => S.map_meet x.val y.val
      inverse := fun y => ⟨S.inverse y, top _⟩
      left_inverse := fun x => Subtype.ext (S.left_inverse x.val)
      right_inverse := fun y => S.right_inverse y }

theorem compression_identification (T K : A) (top : ∀ x, P.le x T)
    (S : MeetIso P (idealOrder P K)) (x : A) :
    (compression P T K top S).right.toFun x =
      (compression P T K top S).left.toFun (S.toFun x).val :=
  (compression P T K top S).represent_old x (top x)

theorem compression_no_new_nodes (T K : A) (top : ∀ x, P.le x T)
    (S : MeetIso P (idealOrder P K)) (x : (compression P T K top S).Node) :
    ∃ a, (compression P T K top S).left.toFun a = x := by
  cases x with
  | inl a => exact ⟨a, rfl⟩
  | inr b => exact False.elim (b.property (top b.val))

theorem compression_top (T K : A) (top : ∀ x, P.le x T)
    (S : MeetIso P (idealOrder P K)) :
    (compression P T K top S).right.toFun T =
      (compression P T K top S).left.toFun K := by
  rw [compression_identification]
  apply congrArg (compression P T K top S).left.toFun
  apply P.antisymm (S.toFun T).property
  have bound := (S.le_iff (S.inverse ⟨K, P.refl K⟩) T).mpr (top _)
  rw [S.right_inverse] at bound
  exact bound

end PartitionPilot.Compression.RecursiveMaps.BinaryTiles

end

end OAI