import OAI.SetTheory.PartitionPrinciple.Forcing.ActionPostcompositionCodes

namespace OAI

section

namespace PartitionPilot.Forcing

universe u

namespace MeetEmbeddingCode

variable {P L rP rL μP μL S : ZFSet.{u}}
variable (embedding : MeetEmbeddingCode P L rP rL μP μL S)

noncomputable def value (x : {x : ZFSet.{u} // x ∈ P}) :
    {y : ZFSet.{u} // y ∈ L} :=
  let graph : FunctionGraphOn P S := ⟨L, embedding.injection.function⟩
  ⟨graph.value x, (ZFSet.pair_mem_prod.1
    (embedding.injection.function.1 (graph.value_entry x))).2⟩

theorem value_entry (x : {x : ZFSet.{u} // x ∈ P}) :
    ZFSet.pair x.val (embedding.value x).val ∈ S :=
  (show FunctionGraphOn P S from ⟨L, embedding.injection.function⟩).value_entry x

theorem value_eq_iff (x : {x : ZFSet.{u} // x ∈ P})
    (y : {y : ZFSet.{u} // y ∈ L}) :
    embedding.value x = y ↔ ZFSet.pair x.val y.val ∈ S := by
  constructor
  · intro equal
    exact equal ▸ embedding.value_entry x
  · intro entry
    exact Subtype.ext ((show FunctionGraphOn P S from
      ⟨L, embedding.injection.function⟩).unique (embedding.value_entry x) entry)

noncomputable def toMeetEmbedding (source : MeetOrderCode P rP μP)
    (target : MeetOrderCode L rL μL) :
    MeetEmbedding source.toMeetOrder target.toMeetOrder where
  toFun := embedding.value
  le_iff x y := embedding.order_iff source target
    (embedding.value_entry x) (embedding.value_entry y)
  map_meet x y := by
    apply Subtype.ext
    exact (show FunctionGraphOn (ZFSet.prod L L) μL from
      ⟨L, target.operation⟩).unique
      (embedding.map_meet _ _ _ _ _ _ (source.toMeetOrder_meet_entry x y)
        (embedding.value_entry x) (embedding.value_entry y)
        (embedding.value_entry (source.toMeetOrder.meet x y)))
      (target.toMeetOrder_meet_entry (embedding.value x) (embedding.value y))

theorem toMeetEmbedding_entry (source : MeetOrderCode P rP μP)
    (target : MeetOrderCode L rL μL) (x : {x : ZFSet.{u} // x ∈ P}) :
    ZFSet.pair x.val ((embedding.toMeetEmbedding source target).toFun x).val ∈ S :=
  embedding.value_entry x

theorem toMeetEmbedding_eq_iff (source : MeetOrderCode P rP μP)
    (target : MeetOrderCode L rL μL) (x : {x : ZFSet.{u} // x ∈ P})
    (y : {y : ZFSet.{u} // y ∈ L}) :
    (embedding.toMeetEmbedding source target).toFun x = y ↔
      ZFSet.pair x.val y.val ∈ S := embedding.value_eq_iff x y

end MeetEmbeddingCode

namespace PosetActionCode

variable {G P m inv e r μ A : ZFSet.{u}}
variable (action : PosetActionCode G P m e r A)

noncomputable def rawAct (g : {g : ZFSet.{u} // g ∈ G})
    (x : {x : ZFSet.{u} // x ∈ P}) : {y : ZFSet.{u} // y ∈ P} :=
  let graph : FunctionGraphOn (ZFSet.prod G P) A := ⟨P, action.function⟩
  let input := (⟨ZFSet.pair g.val x.val,
    ZFSet.pair_mem_prod.2 ⟨g.property, x.property⟩⟩ :
      {z : ZFSet.{u} // z ∈ ZFSet.prod G P})
  ⟨graph.value input, (ZFSet.pair_mem_prod.1
    (action.function.1 (graph.value_entry input))).2⟩

theorem rawAct_entry (g : {g : ZFSet.{u} // g ∈ G})
    (x : {x : ZFSet.{u} // x ∈ P}) :
    ZFSet.pair (ZFSet.pair g.val x.val) (action.rawAct g x).val ∈ A :=
  (show FunctionGraphOn (ZFSet.prod G P) A from ⟨P, action.function⟩).value_entry
    ⟨ZFSet.pair g.val x.val, ZFSet.pair_mem_prod.2 ⟨g.property, x.property⟩⟩

theorem rawAct_eq_iff (g : {g : ZFSet.{u} // g ∈ G})
    (x y : {x : ZFSet.{u} // x ∈ P}) :
    action.rawAct g x = y ↔ ZFSet.pair (ZFSet.pair g.val x.val) y.val ∈ A := by
  constructor
  · intro equal
    exact equal ▸ action.rawAct_entry g x
  · intro entry
    exact Subtype.ext ((show FunctionGraphOn (ZFSet.prod G P) A from
      ⟨P, action.function⟩).unique (action.rawAct_entry g x) entry)

theorem rawAct_injective (group : GroupCode G m inv e) (order : PartialOrderCode P r)
    (g : {g : ZFSet.{u} // g ∈ G}) : Function.Injective (action.rawAct g) := by
  intro x y equal
  have lower : ZFSet.pair (action.rawAct g x).val (action.rawAct g y).val ∈ r := by
    rw [equal]
    exact order.refl _ (action.rawAct g y).property
  have back : ZFSet.pair (action.rawAct g y).val (action.rawAct g x).val ∈ r := by
    rw [equal]
    exact order.refl _ (action.rawAct g y).property
  exact Subtype.ext (order.antisymm x.val x.property y.val y.property
    ((action.raw_order_iff group order g.property
      (action.rawAct_entry g x) (action.rawAct_entry g y)).1 lower)
    ((action.raw_order_iff group order g.property
      (action.rawAct_entry g y) (action.rawAct_entry g x)).1 back))

theorem rawAct_surjective (group : GroupCode G m inv e)
    (g : {g : ZFSet.{u} // g ∈ G}) : Function.Surjective (action.rawAct g) := by
  intro y
  obtain ⟨x, hx, entry⟩ := action.raw_preimage group g.property y.property
  exact ⟨⟨x, hx⟩, (action.rawAct_eq_iff g ⟨x, hx⟩ y).2 entry⟩

noncomputable def toMeetIso (group : GroupCode G m inv e) (meet : MeetOrderCode P r μ)
    (g : {g : ZFSet.{u} // g ∈ G}) :
    Compression.MeetIso meet.toMeetOrder meet.toMeetOrder where
  toFun := action.rawAct g
  le_iff x y := action.raw_order_iff group meet.order g.property
    (action.rawAct_entry g x) (action.rawAct_entry g y)
  map_meet x y := by
    apply Subtype.ext
    exact (show FunctionGraphOn (ZFSet.prod P P) μ from ⟨P, meet.operation⟩).unique
      (action.raw_map_meet group meet g.property (meet.toMeetOrder_meet_entry x y)
        (action.rawAct_entry g x) (action.rawAct_entry g y)
        (action.rawAct_entry g (meet.toMeetOrder.meet x y)))
      (meet.toMeetOrder_meet_entry (action.rawAct g x) (action.rawAct g y))
  inverse y := Classical.choose (action.rawAct_surjective group g y)
  left_inverse x := action.rawAct_injective group meet.order g
    (Classical.choose_spec (action.rawAct_surjective group g (action.rawAct g x)))
  right_inverse y := Classical.choose_spec (action.rawAct_surjective group g y)

theorem toMeetIso_entry (group : GroupCode G m inv e) (meet : MeetOrderCode P r μ)
    (g : {g : ZFSet.{u} // g ∈ G}) (x : {x : ZFSet.{u} // x ∈ P}) :
    ZFSet.pair (ZFSet.pair g.val x.val)
      ((action.toMeetIso group meet g).toFun x).val ∈ A := action.rawAct_entry g x

theorem toMeetIso_eq_iff (group : GroupCode G m inv e) (meet : MeetOrderCode P r μ)
    (g : {g : ZFSet.{u} // g ∈ G}) (x y : {x : ZFSet.{u} // x ∈ P}) :
    (action.toMeetIso group meet g).toFun x = y ↔
      ZFSet.pair (ZFSet.pair g.val x.val) y.val ∈ A := action.rawAct_eq_iff g x y

end PosetActionCode

end PartitionPilot.Forcing

end

end OAI