import OAI.SetTheory.PartitionPrinciple.Definability.ExternalRealization

namespace OAI

section

namespace PartitionPilot.Compression.RecursiveMaps.FixedTop

open CosetGeometry
universe u
variable {A J : Type u} (P : MeetOrder A)

def Le : Option A → Option A → Prop
  | _, none => True
  | none, some _ => False
  | some x, some y => P.le x y

def meet : Option A → Option A → Option A
  | none, y => y
  | x, none => x
  | some x, some y => some (P.meet x y)

def order : MeetOrder (Option A) where
  le := Le P
  meet := meet P
  refl x := by
    cases x with
    | none => trivial
    | some x => exact P.refl x
  trans {x y z} hxy hyz := by
    cases x <;> cases y <;> cases z <;> simp only [Le] at *
    exact P.trans hxy hyz
  antisymm {x y} hxy hyx := by
    cases x <;> cases y <;> simp only [Le] at *
    exact congrArg some (P.antisymm hxy hyx)
  meet_le_left x y := by
    cases x <;> cases y <;> simp only [meet, Le]
    · exact P.refl _
    · exact P.meet_le_left _ _
  meet_le_right x y := by
    cases x <;> cases y <;> simp only [meet, Le]
    · exact P.refl _
    · exact P.meet_le_right _ _
  le_meet {x y z} hxy hxz := by
    cases x <;> cases y <;> cases z <;> simp only [meet, Le] at *
    all_goals first | exact hxy | exact hxz | exact P.le_meet hxy hxz

def embedding : IdealEmbedding P (order P) where
  toFun := some
  le_iff _ _ := Iff.rfl
  map_meet _ _ := rfl
  ideal x z h := by
    cases z with
    | none => exact False.elim h
    | some z => exact ⟨z, rfl⟩

theorem strict_top (x : A) : (order P).le ((embedding P).toFun x) none ∧
    ¬ (order P).le none ((embedding P).toFun x) := ⟨True.intro, id⟩

theorem greatest (x : Option A) : (order P).le x none := by
  cases x <;> exact True.intro

theorem no_new_below (x : A) (z : Option A) (h : (order P).le z ((embedding P).toFun x)) :
    ∃ y, (embedding P).toFun y = z := (embedding P).ideal x z h

variable [Group J] (a : OrderAction J P)

def act (g : J) : Option A → Option A
  | none => none
  | some x => some ((a.iso g).toFun x)

def actionIso (g : J) : MeetIso (order P) (order P) where
  toFun := act P a g
  le_iff x y := by
    cases x <;> cases y <;> simp only [act, order, Le]
    exact (a.iso g).le_iff _ _
  map_meet x y := by
    cases x <;> cases y <;> simp only [act, order, meet]
    exact congrArg some ((a.iso g).map_meet _ _)
  inverse
    | none => none
    | some x => some ((a.iso g).inverse x)
  left_inverse x := by
    cases x with
    | none => rfl
    | some x => exact congrArg some ((a.iso g).left_inverse x)
  right_inverse x := by
    cases x with
    | none => rfl
    | some x => exact congrArg some ((a.iso g).right_inverse x)

def action : OrderAction J (order P) where
  iso := actionIso P a
  one x := by
    cases x with
    | none => rfl
    | some x => exact congrArg some (a.one x)
  mul g h x := by
    cases x with
    | none => rfl
    | some x => exact congrArg some (a.mul g h x)

theorem fixes_top (g : J) : ((action P a).iso g).toFun none = none := rfl

theorem extends_action (g : J) (x : A) :
    ((action P a).iso g).toFun ((embedding P).toFun x) =
      (embedding P).toFun ((a.iso g).toFun x) := rfl

end PartitionPilot.Compression.RecursiveMaps.FixedTop

namespace PartitionPilot.Compression.RecursiveMaps.TileRequests.Family

open CosetGeometry
universe u
variable {A J R : Type u} [Group J] {P : MeetOrder A}
variable (f : Family P R) (a : OrderAction J P)

def Extension := Option (f.Node a)
noncomputable def extensionOrder : MeetOrder (f.Extension a) := FixedTop.order (f.gluedOrder a)
noncomputable def extensionAction : OrderAction (External J f.Letters) (f.extensionOrder a) :=
  FixedTop.action (f.gluedOrder a) (f.externalAction a)
noncomputable def extensionCopy (w : External J f.Letters) : IdealEmbedding P (f.extensionOrder a) :=
  (f.copy a w).comp (FixedTop.embedding (f.gluedOrder a))

theorem extension_greatest (x : f.Extension a) : (f.extensionOrder a).le x none :=
  FixedTop.greatest (f.gluedOrder a) x

theorem extension_strict_top (w : External J f.Letters) (x : A) :
    (f.extensionOrder a).le ((f.extensionCopy a w).toFun x) none ∧
      ¬ (f.extensionOrder a).le none ((f.extensionCopy a w).toFun x) :=
  FixedTop.strict_top (f.gluedOrder a) ((f.copy a w).toFun x)

theorem extension_fixes_top (g : External J f.Letters) :
    ((f.extensionAction a).iso g).toFun none = none := rfl

theorem extensionAction_copy (g w : External J f.Letters) (x : A) :
    ((f.extensionAction a).iso g).toFun ((f.extensionCopy a w).toFun x) =
      (f.extensionCopy a (g * w)).toFun x :=
  congrArg some (f.externalAction_copy a g w x)

theorem extension_extends_old (j : J) (x : A) :
    ((f.extensionAction a).iso (old J f.Letters j)).toFun ((f.extensionCopy a 1).toFun x) =
      (f.extensionCopy a 1).toFun ((a.iso j).toFun x) :=
  congrArg some (f.extends_old_action a j x)

theorem extensionCopy_principal (w : External J f.Letters) (z : f.Extension a) :
    (f.extensionOrder a).le z ((f.extensionCopy a w).toFun f.top) ↔
      ∃ x, (f.extensionCopy a w).toFun x = z :=
  (f.extensionCopy a w).principal f.top f.greatest z

end PartitionPilot.Compression.RecursiveMaps.TileRequests.Family

end

end OAI