lean/OAI/SetTheory/PartitionPrinciple/Forcing/ActionPostcompositionCodes.lean

import OAI.SetTheory.PartitionPrinciple.Geometry.GroundSingleAttachment

namespace OAI

namespace PartitionPilot.Forcing

universe u

structure RestrictedActionCode (P r A g source target base : ZFSet.{u}) : Prop where
  shape : base ⊆ ZFSet.prod P P
  target_entry : ZFSet.pair (ZFSet.pair g source) target ∈ A
  entries : ∀ x ∈ P, ∀ y ∈ P, ZFSet.pair x y ∈ base ↔
    ZFSet.pair x source ∈ r ∧ ZFSet.pair (ZFSet.pair g x) y ∈ A

noncomputable def restrictedActionGraph (P r A g source : ZFSet.{u}) : ZFSet.{u} :=
  ZFSet.sep (fun z => ∃ x ∈ P, ∃ y ∈ P, z = ZFSet.pair x y ∧
    ZFSet.pair x source ∈ r ∧ ZFSet.pair (ZFSet.pair g x) y ∈ A) (ZFSet.prod P P)

theorem restrictedActionGraph_subset (P r A g source : ZFSet.{u}) :
    restrictedActionGraph P r A g source ⊆ ZFSet.prod P P :=
  fun _ hz => (ZFSet.mem_sep.1 hz).1

theorem pair_mem_restrictedActionGraph (P r A g source x y : ZFSet.{u}) :
    ZFSet.pair x y ∈ restrictedActionGraph P r A g source ↔
      x ∈ P ∧ y ∈ P ∧ ZFSet.pair x source ∈ r ∧ ZFSet.pair (ZFSet.pair g x) y ∈ A := by
  rw [restrictedActionGraph, ZFSet.mem_sep, ZFSet.pair_mem_prod]
  constructor
  · rintro ⟨⟨hx, hy⟩, a, _, b, _, eq, lower, entry⟩
    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 eq
    exact ⟨hx, hy, lower, entry⟩
  · rintro ⟨hx, hy, lower, entry⟩
    exact ⟨⟨hx, hy⟩, x, hx, y, hy, rfl, lower, entry⟩

theorem restrictedActionGraph_code {P r A g source target : ZFSet.{u}}
    (target_entry : ZFSet.pair (ZFSet.pair g source) target ∈ A) :
    RestrictedActionCode P r A g source target (restrictedActionGraph P r A g source) where
  shape := restrictedActionGraph_subset P r A g source
  target_entry := target_entry
  entries x hx y hy := by simp only [pair_mem_restrictedActionGraph, hx, hy, true_and]

namespace PosetActionCode

open SetRealization

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

theorem raw_order_iff (group : GroupCode G m inv e) (order : PartialOrderCode P r)
    {g x y x' y' : ZFSet.{u}} (hg : g ∈ G)
    (xx' : ZFSet.pair (ZFSet.pair g x) x' ∈ A)
    (yy' : ZFSet.pair (ZFSet.pair g y) y' ∈ A) :
    ZFSet.pair x' y' ∈ r ↔ ZFSet.pair x y ∈ r := by
  have sx := ZFSet.pair_mem_prod.1 (action.function.1 xx')
  have sy := ZFSet.pair_mem_prod.1 (action.function.1 yy')
  have hx := (ZFSet.pair_mem_prod.1 sx.1).2
  have hy := (ZFSet.pair_mem_prod.1 sy.1).2
  let actor : SetMembers G := SetMembers.ofMem g hg
  let X : SetMembers P := SetMembers.ofMem x hx
  let Y : SetMembers P := SetMembers.ofMem y hy
  have eqX : action.act actor X = SetMembers.ofMem x' sx.2 := by
    apply (action.act_eq_iff actor X _).2
    simpa only [actor, X, SetMembers.raw_ofMem] using xx'
  have eqY : action.act actor Y = SetMembers.ofMem y' sy.2 := by
    apply (action.act_eq_iff actor Y _).2
    simpa only [actor, Y, SetMembers.raw_ofMem] using yy'
  have law := action.act_le_iff group order actor X Y
  rw [eqX, eqY] at law
  change (ZFSet.pair (SetMembers.raw (SetMembers.ofMem x' sx.2))
      (SetMembers.raw (SetMembers.ofMem y' sy.2)) ∈ r ↔
    ZFSet.pair (SetMembers.raw X) (SetMembers.raw Y) ∈ r) at law
  simpa only [X, Y, SetMembers.raw_ofMem] using law

theorem raw_preimage (group : GroupCode G m inv e) {g y : ZFSet.{u}}
    (hg : g ∈ G) (hy : y ∈ P) :
    ∃ x ∈ P, ZFSet.pair (ZFSet.pair g x) y ∈ A := by
  let := group.toGroup
  let actor : SetMembers G := SetMembers.ofMem g hg
  let Y : SetMembers P := SetMembers.ofMem y hy
  let X := action.act actor⁻¹ Y
  refine ⟨SetMembers.raw X, SetMembers.raw_mem X, ?_⟩
  simpa only [actor, Y, SetMembers.raw_ofMem] using
    (action.act_eq_iff actor X Y).1 (action.act_inv_right group actor Y)

theorem raw_map_meet {meetGraph : ZFSet.{u}}
    (group : GroupCode G m inv e) (meet : MeetOrderCode P r meetGraph)
    {g x y z x' y' z' : ZFSet.{u}} (hg : g ∈ G)
    (xyz : ZFSet.pair (ZFSet.pair x y) z ∈ meetGraph)
    (xx' : ZFSet.pair (ZFSet.pair g x) x' ∈ A)
    (yy' : ZFSet.pair (ZFSet.pair g y) y' ∈ A)
    (zz' : ZFSet.pair (ZFSet.pair g z) z' ∈ A) :
    ZFSet.pair (ZFSet.pair x' y') z' ∈ meetGraph := by
  have hx' := (ZFSet.pair_mem_prod.1 (action.function.1 xx')).2
  have hy' := (ZFSet.pair_mem_prod.1 (action.function.1 yy')).2
  have hz' := (ZFSet.pair_mem_prod.1 (action.function.1 zz')).2
  apply meet.pair_iff.2
  refine ⟨hx', hy', hz',
    (action.raw_order_iff group meet.order hg zz' xx').2 (meet.lower_left x y z xyz),
    (action.raw_order_iff group meet.order hg zz' yy').2 (meet.lower_right x y z xyz), ?_⟩
  intro w hw wx' wy'
  obtain ⟨v, hv, vw⟩ := action.raw_preimage group hg hw
  exact (action.raw_order_iff group meet.order hg vw zz').2
    (meet.greatest x y z v hv xyz
      ((action.raw_order_iff group meet.order hg vw xx').1 wx')
      ((action.raw_order_iff group meet.order hg vw yy').1 wy'))

end PosetActionCode

namespace RestrictedActionCode

variable {P r A g source target base : ZFSet.{u}}
variable (code : RestrictedActionCode P r A g source target base)
include code

theorem eq_graph : base = restrictedActionGraph P r A g source := by
  apply ZFSet.ext
  intro z
  constructor
  · intro hz
    obtain ⟨x, hx, y, hy, rfl⟩ := ZFSet.mem_prod.1 (code.shape hz)
    exact (pair_mem_restrictedActionGraph P r A g source x y).2
      ⟨hx, hy, (code.entries x hx y hy).1 hz⟩
  · intro hz
    obtain ⟨x, hx, y, hy, rfl⟩ := ZFSet.mem_prod.1
      (restrictedActionGraph_subset P r A g source hz)
    exact (code.entries x hx y hy).2
      ((pair_mem_restrictedActionGraph P r A g source x y).1 hz).2.2

theorem entry_action {x y : ZFSet.{u}} (entry : ZFSet.pair x y ∈ base) :
    ZFSet.pair (ZFSet.pair g x) y ∈ A := by
  have shape := ZFSet.pair_mem_prod.1 (code.shape entry)
  exact ((code.entries x shape.1 y shape.2).1 entry).2

theorem base_function {G m e : ZFSet.{u}} (action : PosetActionCode G P m e r A)
    (hg : g ∈ G) : ZFSet.IsFunc (attachmentIdeal P r source) P base := by
  refine ⟨?_, ?_⟩
  · intro z hz
    obtain ⟨x, hx, y, hy, rfl⟩ := ZFSet.mem_prod.1 (code.shape hz)
    exact ZFSet.pair_mem_prod.2
      ⟨(mem_attachmentIdeal P r source x).2 ⟨hx, ((code.entries x hx y hy).1 hz).1⟩, hy⟩
  · intro x hx
    have parts := (mem_attachmentIdeal P r source x).1 hx
    obtain ⟨y, entry, unique⟩ := action.function.2 (ZFSet.pair g x)
      (ZFSet.pair_mem_prod.2 ⟨hg, parts.1⟩)
    have hy := (ZFSet.pair_mem_prod.1 (action.function.1 entry)).2
    exact ⟨y, (code.entries x parts.1 y hy).2 ⟨parts.2, entry⟩,
      fun z hz => unique z (code.entry_action hz)⟩

theorem source_entry (order : PartialOrderCode P r) (hsource : source ∈ P)
    (htarget : target ∈ P) : ZFSet.pair source target ∈ base :=
  (code.entries source hsource target htarget).2
    ⟨order.refl source hsource, code.target_entry⟩

theorem base_order {G m inv e : ZFSet.{u}} (group : GroupCode G m inv e)
    (action : PosetActionCode G P m e r A) (order : PartialOrderCode P r) (hg : g ∈ G)
    {x y x' y' : ZFSet.{u}} (xx' : ZFSet.pair x x' ∈ base)
    (yy' : ZFSet.pair y y' ∈ base) :
    ZFSet.pair x' y' ∈ r ↔ ZFSet.pair x y ∈ r :=
  action.raw_order_iff group order hg (code.entry_action xx') (code.entry_action yy')

theorem base_meet {G m inv e μ : ZFSet.{u}} (group : GroupCode G m inv e)
    (action : PosetActionCode G P m e r A) (meet : MeetOrderCode P r μ) (hg : g ∈ G)
    {x y z x' y' z' : ZFSet.{u}} (xyz : ZFSet.pair (ZFSet.pair x y) z ∈ μ)
    (xx' : ZFSet.pair x x' ∈ base) (yy' : ZFSet.pair y y' ∈ base)
    (zz' : ZFSet.pair z z' ∈ base) : ZFSet.pair (ZFSet.pair x' y') z' ∈ μ :=
  action.raw_map_meet group meet hg xyz (code.entry_action xx')
    (code.entry_action yy') (code.entry_action zz')

theorem image_iff {G m inv e : ZFSet.{u}} (group : GroupCode G m inv e)
    (action : PosetActionCode G P m e r A) (order : PartialOrderCode P r)
    (hg : g ∈ G) {y : ZFSet.{u}} :
    (∃ x ∈ attachmentIdeal P r source, ZFSet.pair x y ∈ base) ↔
      y ∈ attachmentIdeal P r target := by
  constructor
  · rintro ⟨x, hx, entry⟩
    have hy := (ZFSet.pair_mem_prod.1 (code.shape entry)).2
    exact (mem_attachmentIdeal P r target y).2 ⟨hy,
      (action.raw_order_iff group order hg (code.entry_action entry) code.target_entry).2
        ((mem_attachmentIdeal P r source x).1 hx).2⟩
  · intro hy
    have parts := (mem_attachmentIdeal P r target y).1 hy
    obtain ⟨x, hx, entry⟩ := action.raw_preimage group hg parts.1
    have lower := (action.raw_order_iff group order hg entry code.target_entry).1 parts.2
    exact ⟨x, (mem_attachmentIdeal P r source x).2 ⟨hx, lower⟩,
      (code.entries x hx y parts.1).2 ⟨lower, entry⟩⟩

theorem singleAttachmentInputs {G m inv e μ F separator : ZFSet.{u}}
    (group : GroupCode G m inv e) (action : PosetActionCode G P m e r A)
    (meet : MeetOrderCode P r μ) (hg : g ∈ G) (hsource : source ∈ P)
    (htarget : target ∈ P) (filter : MeetFilterCode P r μ F)
    (hseparator : separator ∈ P) (lower : ZFSet.pair target separator ∈ r)
    (strict : ZFSet.pair separator target ∉ r)
    (upper : ∀ y ∈ F, ZFSet.pair separator y ∈ r) :
    SingleAttachmentInputs P P r r μ μ base F source separator := by
  have function := code.base_function action hg
  have targetEntry := code.source_entry meet.order hsource htarget
  have value_eq (b : ZFSet.{u}) (entry : ZFSet.pair source b ∈ base) : b = target := by
    obtain ⟨v, _, unique⟩ := function.2 source
      ((mem_attachmentIdeal P r source source).2 ⟨hsource, meet.order.refl source hsource⟩)
    exact (unique b entry).trans (unique target targetEntry).symm
  exact {
    oldOrder := meet
    templateOrder := meet
    anchor_mem := hsource
    base_function := function
    base_order := fun _ _ _ _ xx' yy' => code.base_order group action meet.order hg xx' yy'
    base_meet := fun _ _ _ _ _ _ xyz xx' yy' zz' => code.base_meet group action meet hg xyz xx' yy' zz'
    filter := filter
    separator_mem := hseparator
    base_le_separator := fun b entry => (value_eq b entry).symm ▸ lower
    separator_not_le_base := fun b entry => (value_eq b entry).symm ▸ strict
    separator_le_upper := upper }

end RestrictedActionCode

noncomputable def actionPostcompose (P A g base : ZFSet.{u}) : ZFSet.{u} :=
  ZFSet.sep (fun v => ∃ x ∈ P, ∃ z ∈ P, v = ZFSet.pair x z ∧
    ∃ y ∈ P, ZFSet.pair x y ∈ base ∧ ZFSet.pair (ZFSet.pair g y) z ∈ A) (ZFSet.prod P P)

theorem actionPostcompose_subset (P A g base : ZFSet.{u}) :
    actionPostcompose P A g base ⊆ ZFSet.prod P P :=
  fun _ hv => (ZFSet.mem_sep.1 hv).1

theorem pair_mem_actionPostcompose (P A g base x z : ZFSet.{u}) :
    ZFSet.pair x z ∈ actionPostcompose P A g base ↔
      x ∈ P ∧ z ∈ P ∧ ∃ y ∈ P,
        ZFSet.pair x y ∈ base ∧ ZFSet.pair (ZFSet.pair g y) z ∈ A := by
  rw [actionPostcompose, ZFSet.mem_sep, ZFSet.pair_mem_prod]
  constructor
  · rintro ⟨⟨hx, hz⟩, a, _, b, _, equal, witness⟩
    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
    exact ⟨hx, hz, witness⟩
  · rintro ⟨hx, hz, witness⟩
    exact ⟨⟨hx, hz⟩, x, hx, z, hz, rfl, witness⟩

theorem PosetActionCode.raw_mul_iff {G P m e r A g h k x z : ZFSet.{u}}
    (action : PosetActionCode G P m e r A) (hg : g ∈ G) (hh : h ∈ G) (hk : k ∈ G)
    (product : ZFSet.pair (ZFSet.pair g h) k ∈ m) (hx : x ∈ P) (hz : z ∈ P) :
    ZFSet.pair (ZFSet.pair k x) z ∈ A ↔
      ∃ y ∈ P, ZFSet.pair (ZFSet.pair h x) y ∈ A ∧ ZFSet.pair (ZFSet.pair g y) z ∈ A := by
  constructor
  · intro entry
    obtain ⟨y, first, _⟩ := action.function.2 (ZFSet.pair h x)
      (ZFSet.pair_mem_prod.2 ⟨hh, hx⟩)
    have hy := (ZFSet.pair_mem_prod.1 (action.function.1 first)).2
    obtain ⟨w, second, _⟩ := action.function.2 (ZFSet.pair g y)
      (ZFSet.pair_mem_prod.2 ⟨hg, hy⟩)
    have hw := (ZFSet.pair_mem_prod.1 (action.function.1 second)).2
    have composed := action.mul g hg h hh k hk x hx y hy w hw product first second
    obtain ⟨v, _, unique⟩ := action.function.2 (ZFSet.pair k x)
      (ZFSet.pair_mem_prod.2 ⟨hk, hx⟩)
    have equal : w = z := (unique w composed).trans (unique z entry).symm
    exact ⟨y, hy, first, equal ▸ second⟩
  · rintro ⟨y, hy, first, second⟩
    exact action.mul g hg h hh k hk x hx y hy z hz product first second

theorem actionPostcompose_one {G P m e r A base : ZFSet.{u}}
    (action : PosetActionCode G P m e r A) (shape : base ⊆ ZFSet.prod P P) :
    actionPostcompose P A e base = base := by
  apply ZFSet.ext
  intro v
  constructor
  · intro hv
    obtain ⟨x, _, z, _, rfl⟩ := ZFSet.mem_prod.1 (actionPostcompose_subset P A e base hv)
    obtain ⟨_, _, y, hy, entry, acted⟩ := (pair_mem_actionPostcompose P A e base x z).1 hv
    have identity := action.one y hy
    obtain ⟨w, _, unique⟩ := action.function.2 (ZFSet.pair e y)
      (ZFSet.pair_mem_prod.1 (action.function.1 identity)).1
    have equal : z = y := (unique z acted).trans (unique y identity).symm
    exact equal.symm ▸ entry
  · intro hv
    obtain ⟨x, hx, y, hy, rfl⟩ := ZFSet.mem_prod.1 (shape hv)
    exact (pair_mem_actionPostcompose P A e base x y).2
      ⟨hx, hy, y, hy, hv, action.one y hy⟩

theorem actionPostcompose_mul {G P m e r A base g h k : ZFSet.{u}}
    (action : PosetActionCode G P m e r A)
    (hg : g ∈ G) (hh : h ∈ G) (hk : k ∈ G)
    (product : ZFSet.pair (ZFSet.pair g h) k ∈ m) :
    actionPostcompose P A k base = actionPostcompose P A g (actionPostcompose P A h base) := by
  apply ZFSet.ext
  intro v
  constructor
  · intro hv
    obtain ⟨x, _, z, _, rfl⟩ := ZFSet.mem_prod.1 (actionPostcompose_subset P A k base hv)
    obtain ⟨hx, hz, y, hy, entry, acted⟩ := (pair_mem_actionPostcompose P A k base x z).1 hv
    obtain ⟨w, hw, first, second⟩ := (action.raw_mul_iff hg hh hk product hy hz).1 acted
    exact (pair_mem_actionPostcompose P A g (actionPostcompose P A h base) x z).2
      ⟨hx, hz, w, hw, (pair_mem_actionPostcompose P A h base x w).2
        ⟨hx, hw, y, hy, entry, first⟩, second⟩
  · intro hv
    obtain ⟨x, _, z, _, rfl⟩ := ZFSet.mem_prod.1
      (actionPostcompose_subset P A g (actionPostcompose P A h base) hv)
    obtain ⟨hx, hz, w, hw, entry, acted⟩ :=
      (pair_mem_actionPostcompose P A g (actionPostcompose P A h base) x z).1 hv
    obtain ⟨_, _, y, hy, first, second⟩ := (pair_mem_actionPostcompose P A h base x w).1 entry
    exact (pair_mem_actionPostcompose P A k base x z).2
      ⟨hx, hz, y, hy, first, (action.raw_mul_iff hg hh hk product hy hz).2
        ⟨w, hw, second, acted⟩⟩

theorem actionPostcompose_inverse {G P m inv e r A base g h : ZFSet.{u}}
    (group : GroupCode G m inv e) (action : PosetActionCode G P m e r A)
    (shape : base ⊆ ZFSet.prod P P) (hg : g ∈ G) (hh : h ∈ G)
    (inverse : ZFSet.pair g h ∈ inv) :
    actionPostcompose P A h (actionPostcompose P A g base) = base := by
  rw [← actionPostcompose_mul action hh hg group.identity_mem (group.inv_mul g hg h hh inverse)]
  exact actionPostcompose_one action shape

theorem RestrictedActionCode.transport {G P m e r A g δ k source target target' base : ZFSet.{u}}
    (code : RestrictedActionCode P r A g source target base)
    (action : PosetActionCode G P m e r A)
    (hg : g ∈ G) (hδ : δ ∈ G) (hk : k ∈ G)
    (product : ZFSet.pair (ZFSet.pair δ g) k ∈ m)
    (targetEntry : ZFSet.pair (ZFSet.pair δ target) target' ∈ A) :
    RestrictedActionCode P r A k source target' (actionPostcompose P A δ base) := by
  have firstShape := ZFSet.pair_mem_prod.1 (action.function.1 code.target_entry)
  have hsource := (ZFSet.pair_mem_prod.1 firstShape.1).2
  have htarget := firstShape.2
  have htarget' := (ZFSet.pair_mem_prod.1 (action.function.1 targetEntry)).2
  refine ⟨actionPostcompose_subset P A δ base,
    action.mul δ hδ g hg k hk source hsource target htarget target' htarget'
      product code.target_entry targetEntry, ?_⟩
  intro x hx z hz
  rw [pair_mem_actionPostcompose]
  constructor
  · rintro ⟨_, _, y, hy, entry, acted⟩
    have old := (code.entries x hx y hy).1 entry
    exact ⟨old.1, (action.raw_mul_iff hδ hg hk product hx hz).2 ⟨y, hy, old.2, acted⟩⟩
  · rintro ⟨lower, entry⟩
    obtain ⟨y, hy, first, second⟩ := (action.raw_mul_iff hδ hg hk product hx hz).1 entry
    exact ⟨hx, hz, y, hy, (code.entries x hx y hy).2 ⟨lower, first⟩, second⟩

end PartitionPilot.Forcing

end OAI