import Mathlib
import OAI.SetTheory.PartitionConsistency.Models.UniformImages
import OAI.SetTheory.PartitionConsistency.Models.OrdinalChoice

namespace OAI

/-! ## LeastOccurrence -/

namespace PartitionConsistency.SetForcingNames.SymmetricSystem
universe u v w
noncomputable section
variable {P : Type w} [PartialOrder P] [OrderTop P] {Γ : Type v} [Group Γ]
variable {S : SymmetricSystem.{u} P Γ}

namespace LeastOccurrence
variable (X : ZFSet.{u}) (R : X → S.UnaryRelation)

/-- Occurrence at this index and forced nonoccurrence at every smaller
index in the fixed ground wellordering. -/
def At (p : P) (x : S.Name) (i : X) : Prop :=
  (R i).holds p x ∧ ∀ j, WellOrderingRel j i → ∀ q, q ≤ p → ¬ (R j).holds q x

omit [OrderTop P] in
theorem mono {p q : P} {x : S.Name} {i : X} (h : q ≤ p) (hi : At X R p x i) : At X R q x i :=
  ⟨(R i).mono h hi.1,fun j hj r hr => hi.2 j hj r (hr.trans h)⟩

omit [OrderTop P] in
theorem congr {p : P} {x y : S.Name} {i : X} (he : S.atomic.EqF p x y) :
    At X R p x i ↔ At X R p y i := by
  have step {x y : S.Name} (he : S.atomic.EqF p x y) (h : At X R p x i) : At X R p y i := by
    refine ⟨((R i).congr he).mp h.1,?_⟩
    intro j hj q hq hy
    exact h.2 j hj q hq (((R j).congr (S.atomic.eq_mono hq he)).mpr hy)
  exact ⟨step he,step (S.atomic.eq_symm he)⟩

omit [OrderTop P] in
theorem unique {p : P} {x : S.Name} {i j : X} (hi : At X R p x i) (hj : At X R p x j) : i = j := by
  rcases trichotomous_of WellOrderingRel i j with hh | hh | hh
  · exact (hj.2 i hh p le_rfl hi.1).elim
  · exact hh
  · exact (hi.2 j hh p le_rfl hj.1).elim

def predicate (i : X) : S.UnaryRelation where
  holds p x := At X R p x i
  mono := mono X R
  regular := by
    intro p x h
    refine ⟨(R i).regular (fun q hq => (h q hq).imp (fun r hr => ⟨hr.1,hr.2.1⟩)),?_⟩
    intro j hj q hq hi
    obtain ⟨r,hrq,hr⟩ := h q hq
    exact hr.2 j hj r le_rfl ((R j).mono hrq hi)
  congr := congr X R

omit [OrderTop P] in
/-- Minimal compatible occurrence exists densely. -/
theorem dense (x : S.Name) (p : P)
    (h : ∀ q, q ≤ p → ∃ r, r ≤ q ∧ ∃ i, (R i).holds r x) :
    ∀ q, q ≤ p → ∃ r, r ≤ q ∧ ∃ i, At X R r x i := by
  intro q hq
  have hne : {i | ∃ r, r ≤ q ∧ (R i).holds r x}.Nonempty := by
    obtain ⟨r,hrq,i,hi⟩ := h q hq
    exact ⟨i,r,hrq,hi⟩
  obtain ⟨i,⟨r,hrq,hi⟩,hmin⟩ := WellOrderingRel.isWellOrder.wf.has_min _ hne
  exact ⟨r,hrq,i,hi,fun j hj s hsr hs => hmin j ⟨s,hsr.trans hrq,hs⟩ hj⟩

omit [OrderTop P] in
theorem move (H : Subgroup Γ)
    (hR : ∀ g ∈ H, ∀ i p x, (R i).holds p x → (R i).holds (S.move g p) (g • x))
    (g : Γ) (hg : g ∈ H) {p : P} {x : S.Name} {i : X} (hi : At X R p x i) :
    At X R (S.move g p) (g • x) i := by
  refine ⟨hR g hg i p x hi.1,?_⟩
  intro j hj q hq hh
  have hback := hR g⁻¹ (H.inv_mem hg) j q (g • x) hh
  have heq : S.move g⁻¹ q = (S.move g).symm q := by
    change S.codeEquiv.symm (S.action.perm g⁻¹ (S.codeEquiv q)) =
      S.codeEquiv.symm ((S.action.perm g).symm (S.codeEquiv q))
    rw [map_inv]
    rfl
  simp only [inv_smul_smul,heq] at hback
  exact hi.2 j hj ((S.move g).symm q) ((S.move g).symm_apply_le.mpr hq) hback

/-- The least-index graph, regularized in both the value and index names. -/
def relation : S.BinaryRelation where
  holds p x y := ∀ q, q ≤ p → ∃ r, r ≤ q ∧ ∃ i : X,
    S.atomic.EqF r y (Name.check i.val) ∧ At X R r x i
  mono h hh q hq := hh q (hq.trans h)
  regular h q hq := by
    obtain ⟨r,hrq,hr⟩ := h q hq
    obtain ⟨s,hsr,i,hi⟩ := hr r le_rfl
    exact ⟨s,hsr.trans hrq,i,hi⟩
  congr := by
    intro p x x' y y' hx hy
    have step {x x' y y' : S.Name} (hx : S.atomic.EqF p x x') (hy : S.atomic.EqF p y y')
        (h : ∀ q, q ≤ p → ∃ r, r ≤ q ∧ ∃ i : X,
          S.atomic.EqF r y (Name.check i.val) ∧ At X R r x i) :
        ∀ q, q ≤ p → ∃ r, r ≤ q ∧ ∃ i : X,
          S.atomic.EqF r y' (Name.check i.val) ∧ At X R r x' i := by
      intro q hq
      obtain ⟨r,hrq,i,hi,hr⟩ := h q hq
      exact ⟨r,hrq,i,S.atomic.eq_trans (S.atomic.eq_symm (S.atomic.eq_mono (hrq.trans hq) hy)) hi,
        (congr X R (S.atomic.eq_mono (hrq.trans hq) hx)).mp hr⟩
    exact ⟨step hx hy,step (S.atomic.eq_symm hx) (S.atomic.eq_symm hy)⟩

theorem relation_one {p : P} {x y z : S.Name}
    (hy : (relation X R).holds p x y) (hz : (relation X R).holds p x z) : S.atomic.EqF p y z := by
  apply S.atomic_regular.1
  intro q hq
  obtain ⟨r,hrq,i,hyi,hi⟩ := hy q hq
  obtain ⟨s,hsr,j,hzj,hj⟩ := hz r (hrq.trans hq)
  have hij := unique X R (mono X R hsr hi) hj
  subst j
  exact ⟨s,hsr.trans hrq,S.atomic.eq_trans (S.atomic.eq_mono hsr hyi) (S.atomic.eq_symm hzj)⟩

theorem relation_inj (p : P)
    (hone : ∀ i q, q ≤ p → ∀ x y, (R i).holds q x → (R i).holds q y → S.atomic.EqF q x y) :
    ∀ q, q ≤ p → ∀ x y z, (relation X R).holds q x z →
      (relation X R).holds q y z → S.atomic.EqF q x y := by
  intro q hq x y z hx hy
  apply S.atomic_regular.1
  intro r hrq
  obtain ⟨s,hsr,i,hzi,hi⟩ := hx r hrq
  obtain ⟨t,hts,j,hzj,hj⟩ := hy s (hsr.trans hrq)
  have hij : i = j := Subtype.ext ((S.eq_check_iff i.val j.val t).mp
    (S.atomic.eq_trans (S.atomic.eq_symm (S.atomic.eq_mono hts hzi)) hzj))
  subst j
  exact ⟨t,hts.trans hsr,hone i t (hts.trans (hsr.trans (hrq.trans hq))) x y
    ((R i).mono hts hi.1) hj.1⟩

theorem relation_move (H : Subgroup Γ)
    (hR : ∀ g ∈ H, ∀ i p x, (R i).holds p x → (R i).holds (S.move g p) (g • x))
    (g : Γ) (hg : g ∈ H) (p : P) (x y : S.Name) (h : (relation X R).holds p x y) :
    (relation X R).holds (S.move g p) (g • x) (g • y) := by
  intro q hq
  obtain ⟨r,hrq,i,he,hi⟩ := h ((S.move g).symm q) ((S.move g).symm_apply_le.mpr hq)
  refine ⟨S.move g r,(S.move g).le_symm_apply.mp hrq,i,?_,move X R H hR g hg hi⟩
  simpa only [Name.smul_check] using (S.eq_symmetry g r y (Name.check i.val)).mp he

/-- Every family of regular occurrences covering a set and with at most one
value at each index supplies an internal injection into the ground index set. -/
theorem exists_injection (Y : S.Name) (H : Subgroup Γ) (hH : H ∈ S.filter)
    (hY : ∀ g ∈ H, g • Y = Y)
    (hR : ∀ g ∈ H, ∀ i p x, (R i).holds p x → (R i).holds (S.move g p) (g • x))
    (p : P)
    (hcover : ∀ x q, q ≤ p → S.atomic.MemF q x Y →
      ∀ r, r ≤ q → ∃ s, s ≤ r ∧ ∃ i, (R i).holds s x)
    (hone : ∀ i q, q ≤ p → ∀ x y, (R i).holds q x → (R i).holds q y → S.atomic.EqF q x y) :
    ∃ f : S.Name, S.Forces ![f,Y,Name.check X] p (SetLanguage.injection 0 1 2) := by
  refine ⟨(relation X R).graph Y (Name.check X) H hH hY (fun g _ => Name.smul_check S g X)
    (relation_move X R H hR),?_⟩
  apply BinaryRelation.graph_injection
  · intro x q hq hx r hrq
    obtain ⟨s,hsr,i,hi⟩ := dense X R x q (hcover x q hq hx) r hrq
    exact ⟨s,hsr,Name.check i.val,S.check_mem_of_mem i.property s,
      fun t hts => ⟨t,le_rfl,i,S.atomic.eq_refl t _,mono X R hts hi⟩⟩
  · intro q _ x y z
    exact relation_one X R
  · exact relation_inj X R p hone

end LeastOccurrence
end
end PartitionConsistency.SetForcingNames.SymmetricSystem


/-! ## WellorderedImage -/

namespace PartitionConsistency.SetForcingNames.SymmetricSystem
universe u v w
noncomputable section
variable {P : Type w} [PartialOrder P] [OrderTop P] {Γ : Type v} [Group Γ]
variable (S : SymmetricSystem.{u} P Γ)

/-- Dense presentation of a wellorderability witness by a ground ordinal. -/
theorem wellorderable_check_dense (X : S.Name) (p : P)
    (h : S.Forces ![X] p (SetLanguage.wellorderable 0)) :
    ∀ q, q ≤ p → ∃ r, r ≤ q ∧ ∃ β : Ordinal.{u}, ∃ J : S.Name,
      S.Forces ![J,X,Name.check β.toZFSet] r (SetLanguage.injection 0 1 2) := by
  intro q hq
  obtain ⟨r,hrq,η,ho,hj⟩ := (S.forces_wellorderable _ _ _).mp h q hq
  obtain ⟨s,hsr,β,he⟩ := S.forces_ordinal_decide ![η] r 0 ho r le_rfl
  obtain ⟨t,hts,J,hJ⟩ := hj s hsr
  refine ⟨t,hts.trans (hsr.trans hrq),β,J,?_⟩
  apply (S.atomic.forceFormula_tuple_congr (p := t) (φ := SetLanguage.injection 0 1 2)
    (v := ![J,X,η]) (w := ![J,X,Name.check β.toZFSet]) ?_).mp hJ
  intro k
  fin_cases k
  · exact S.atomic.eq_refl t J
  · exact S.atomic.eq_refl t X
  · exact S.atomic.eq_mono hts he

/-- The value of a function at the (at most one) point of a given ordinal
index in an injection of its domain. -/
def indexedImage (f J X Y : S.Name) (Ξ : ZFSet.{u}) (i : Ξ) : S.UnaryRelation where
  holds p y := ((S.boundedApp J X (Name.check Ξ)).inverse.comp
    (S.boundedApp f X Y)).holds p (Name.check i.val) y
  mono := BinaryRelation.mono _
  regular := BinaryRelation.regular _
  congr hx := BinaryRelation.congr _ (S.atomic.eq_refl _ _) hx

theorem indexedImage_move (f J X Y : S.Name) (Ξ : ZFSet.{u}) (g : Γ)
    (hf : g • f = f) (hJ : g • J = J) (hX : g • X = X) (hY : g • Y = Y)
    (i : Ξ) (p : P) (y : S.Name) (h : (S.indexedImage f J X Y Ξ i).holds p y) :
    (S.indexedImage f J X Y Ξ i).holds (S.move g p) (g • y) := by
  intro q hq
  obtain ⟨r,hrq,x,hx,hy⟩ := h ((S.move g).symm q) ((S.move g).symm_apply_le.mpr hq)
  refine ⟨S.move g r,(S.move g).le_symm_apply.mp hrq,g • x,?_,
    S.boundedApp_move f X Y g hf hX hY r x y hy⟩
  change (S.boundedApp J X (Name.check Ξ)).holds (S.move g r) (g • x) (Name.check i.val)
  simpa only [Name.smul_check] using
    S.boundedApp_move J X (Name.check Ξ) g hJ hX (Name.smul_check S g Ξ) r x (Name.check i.val) hx

theorem indexedImage_one (f J X Y : S.Name) (Ξ : ZFSet.{u}) (p : P)
    (hf : S.Forces ![f,X,Y] p (SetLanguage.mapsTo 0 1 2))
    (hJ : S.Forces ![J,X,Name.check Ξ] p (SetLanguage.injection 0 1 2)) :
    ∀ i q, q ≤ p → ∀ y z, (S.indexedImage f J X Y Ξ i).holds q y →
      (S.indexedImage f J X Y Ξ i).holds q z → S.atomic.EqF q y z := by
  intro i q hq y z hy hz
  apply S.atomic_regular.1
  intro r hrq
  obtain ⟨s,hsr,x,hx,hxy⟩ := hy r hrq
  obtain ⟨t,hts,a,ha,haz⟩ := hz s (hsr.trans hrq)
  have htp := hts.trans (hsr.trans (hrq.trans hq))
  have hxa := S.injection_one hJ htp (S.atomic.mem_mono hts hx.1) ha.1
    (S.app_mono hts hx.2.2) ha.2.2
  have hay := (S.app_congr (S.atomic.eq_refl t f) hxa (S.atomic.eq_refl t y)).mp
    (S.app_mono hts hxy.2.2)
  exact ⟨t,hts.trans hsr,S.mapsTo_unique hf htp ha.1 hay haz.2.2⟩

theorem indexedImage_cover (f J X Y : S.Name) (Ξ : ZFSet.{u}) (p : P)
    (hf : S.Forces ![f,X,Y] p (SetLanguage.surjection 0 1 2))
    (hJ : S.Forces ![J,X,Name.check Ξ] p (SetLanguage.mapsTo 0 1 2)) :
    ∀ y q, q ≤ p → S.atomic.MemF q y Y →
      ∀ r, r ≤ q → ∃ s, s ≤ r ∧ ∃ i, (S.indexedImage f J X Y Ξ i).holds s y := by
  intro y q hq hy r hrq
  obtain ⟨s,hsr,x,hx,hxy⟩ := S.surjection_onto hf hq hy r hrq
  obtain ⟨t,hts,j,hj,hxj⟩ := S.mapsTo_total hJ (hsr.trans (hrq.trans hq)) hx s le_rfl
  obtain ⟨a,hat,i,hi,hji⟩ := (S.mem_check Ξ j t).mp hj t le_rfl
  refine ⟨a,hat.trans (hts.trans hsr),⟨i,hi⟩,?_⟩
  intro b hba
  have hbs := hba.trans (hat.trans hts)
  refine ⟨b,le_rfl,x,?_,?_⟩
  · exact ⟨S.atomic.mem_mono hbs hx,S.check_mem_of_mem hi b,
      (S.app_congr (S.atomic.eq_refl b J) (S.atomic.eq_refl b x) (S.atomic.eq_mono hba hji)).mp
        (S.app_mono (hba.trans hat) hxj)⟩
  · exact ⟨S.atomic.mem_mono hbs hx,S.atomic.mem_mono (hbs.trans (hsr.trans hrq)) hy,
      S.app_mono hbs hxy⟩

/-- Images of wellorderable sets are wellorderable, by least preimages, not
by a use of Choice. -/
theorem wellorderable_image (f X Y : S.Name) (p : P)
    (hf : S.Forces ![f,X,Y] p (SetLanguage.surjection 0 1 2))
    (hX : S.Forces ![X] p (SetLanguage.wellorderable 0)) :
    S.Forces ![Y] p (SetLanguage.wellorderable 0) := by
  apply S.atomic.forceFormula_of_dense S.atomic_regular
  intro q hq
  obtain ⟨r,hrq,β,J,hJ⟩ := S.wellorderable_check_dense X p hX q hq
  let H := S.tupleStabilizer ![f,J,X,Y]
  have hR : ∀ g ∈ H, ∀ i p y, (S.indexedImage f J X Y β.toZFSet i).holds p y →
      (S.indexedImage f J X Y β.toZFSet i).holds (S.move g p) (g • y) := by
    intro g hg
    exact S.indexedImage_move f J X Y β.toZFSet g
      ((S.mem_tupleStabilizer _ g).mp hg 0) ((S.mem_tupleStabilizer _ g).mp hg 1)
      ((S.mem_tupleStabilizer _ g).mp hg 2) ((S.mem_tupleStabilizer _ g).mp hg 3)
  have hfr := S.atomic.forceFormula_mono (hrq.trans hq) hf
  obtain ⟨K,hK⟩ := LeastOccurrence.exists_injection β.toZFSet
    (S.indexedImage f J X Y β.toZFSet) Y H (S.tupleStabilizer_mem _)
      (fun g hg => (S.mem_tupleStabilizer _ g).mp hg 3) hR r
      (S.indexedImage_cover f J X Y β.toZFSet r hfr (S.injection_mapsTo hJ))
      (S.indexedImage_one f J X Y β.toZFSet r (S.surjection_mapsTo hfr) hJ)
  exact ⟨r,hrq,S.wellorderable_of_check_injection Y K β r hK⟩

end
end PartitionConsistency.SetForcingNames.SymmetricSystem


/-! ## RelationFamily -/

namespace PartitionConsistency.SetForcingNames.SymmetricSystem
universe u v w i
noncomputable section
variable {P : Type w} [PartialOrder P] [OrderTop P] {Γ : Type v} [Group Γ]
variable {S : SymmetricSystem.{u} P Γ}

namespace BinaryRelation
/-- Regular union of an arbitrary indexed family of binary relations. The
bounded graph constructor subsequently makes this relation an actual set. -/
def familyUnion {ι : Sort i} (R : ι → S.BinaryRelation) : S.BinaryRelation where
  holds p x y := ∀ q, q ≤ p → ∃ r, r ≤ q ∧ ∃ i, (R i).holds r x y
  mono h hh q hq := hh q (hq.trans h)
  regular h q hq := by
    obtain ⟨r,hrq,hr⟩ := h q hq
    obtain ⟨s,hsr,i,hi⟩ := hr r le_rfl
    exact ⟨s,hsr.trans hrq,i,hi⟩
  congr := by
    intro p x x' y y' hx hy
    have step {x x' y y' : S.Name} (hx : S.atomic.EqF p x x') (hy : S.atomic.EqF p y y')
        (h : ∀ q, q ≤ p → ∃ r, r ≤ q ∧ ∃ i, (R i).holds r x y) :
        ∀ q, q ≤ p → ∃ r, r ≤ q ∧ ∃ i, (R i).holds r x' y' := by
      intro q hq
      obtain ⟨r,hrq,i,hi⟩ := h q hq
      exact ⟨r,hrq,i,((R i).congr (S.atomic.eq_mono (hrq.trans hq) hx)
        (S.atomic.eq_mono (hrq.trans hq) hy)).mp hi⟩
    exact ⟨step hx hy,step (S.atomic.eq_symm hx) (S.atomic.eq_symm hy)⟩

omit [OrderTop P] in
theorem familyUnion_move {ι : Sort i} (R : ι → S.BinaryRelation) (g : Γ)
    (hR : ∀ i p x y, (R i).holds p x y → (R i).holds (S.move g p) (g • x) (g • y))
    (p : P) (x y : S.Name) (h : (familyUnion R).holds p x y) :
    (familyUnion R).holds (S.move g p) (g • x) (g • y) := by
  intro q hq
  obtain ⟨r,hrq,i,hi⟩ := h ((S.move g).symm q) ((S.move g).symm_apply_le.mpr hq)
  exact ⟨S.move g r,(S.move g).le_symm_apply.mp hrq,i,hR i r x y hi⟩

def atLeft (R : S.BinaryRelation) (x : S.Name) : S.UnaryRelation where
  holds p y := R.holds p x y
  mono := R.mono
  regular := R.regular
  congr h := R.congr (S.atomic.eq_refl _ _) h

def atRight (R : S.BinaryRelation) (y : S.Name) : S.UnaryRelation := R.inverse.atLeft y

end BinaryRelation

namespace UnaryRelation

def member (X : S.Name) : S.UnaryRelation where
  holds p x := S.atomic.MemF p x X
  mono := S.atomic.mem_mono
  regular := S.atomic_regular.2 _ _ _
  congr h := S.atomic.mem_congr h (S.atomic.eq_refl _ _)

def neg (R : S.UnaryRelation) : S.UnaryRelation where
  holds p x := ∀ q, q ≤ p → ¬ R.holds q x
  mono h hh q hq := hh q (hq.trans h)
  regular h q hq hx := by
    obtain ⟨r,hrq,hr⟩ := h q hq
    exact hr r le_rfl (R.mono hrq hx)
  congr := by
    intro p x y he
    have step {x y : S.Name} (he : S.atomic.EqF p x y)
        (h : ∀ q, q ≤ p → ¬ R.holds q x) : ∀ q, q ≤ p → ¬ R.holds q y := by
      intro q hq hy
      exact h q hq ((R.congr (S.atomic.eq_mono hq he)).mpr hy)
    exact ⟨step he,step (S.atomic.eq_symm he)⟩

end UnaryRelation
end
end PartitionConsistency.SetForcingNames.SymmetricSystem


/-! ## WellorderedSection -/

namespace PartitionConsistency.SetLanguage
/-- A preimage for the (possibly absent) value at one ordinal index. -/
def indexedSection : Formula 6 :=
  .all ((Formula.mem 6 2).imp ((edge 3 6 4).imp ((Formula.mem 5 1).conj (edge 0 5 6))))
end PartitionConsistency.SetLanguage

namespace PartitionConsistency.SetForcingNames.SymmetricSystem
universe u v w
noncomputable section
variable {P : Type w} [PartialOrder P] [OrderTop P] {Γ : Type v} [Group Γ]
variable (S : SymmetricSystem.{u} P Γ)

omit [OrderTop P] in
theorem forces_indexedSection (f X Y J i x : S.Name) (p : P) :
    S.Forces ![f,X,Y,J,i,x] p SetLanguage.indexedSection ↔
      ∀ y q, q ≤ p → S.atomic.MemF q y Y →
        ∀ r, r ≤ q → S.App r J y i → S.atomic.MemF r x X ∧ S.App r f x y := by
  simp only [Forces,SetLanguage.indexedSection,S.atomic.forceFormula_all S.atomic_regular,
    S.atomic.forceFormula_imp S.atomic_regular,ForcingQuotient.AtomicData.forceFormula_mem,
    ForcingQuotient.AtomicData.forceFormula_conj,S.forces_edge]
  rfl

omit [OrderTop P] in
/-- One fiber can be chosen without any simultaneous use of choice; an
unoccupied ordinal index imposes no requirement on the selected name. -/
theorem indexedSection_exists (f X Y J O i : S.Name) (p : P)
    (hf : S.Forces ![f,X,Y] p (SetLanguage.surjection 0 1 2))
    (hJ : S.Forces ![J,Y,O] p (SetLanguage.injection 0 1 2)) :
    S.Forces ![f,X,Y,J,i] p SetLanguage.indexedSection.ex := by
  intro q hq
  by_cases h : ∃ r, r ≤ q ∧ ∃ y, S.atomic.MemF r y Y ∧ S.App r J y i
  · obtain ⟨r,hrq,y,hy,hyi⟩ := h
    obtain ⟨s,hsr,x,hx,hxy⟩ := S.surjection_onto hf (hrq.trans hq) hy r le_rfl
    refine ⟨s,hsr.trans hrq,x,?_⟩
    have hv : Fin.snoc ![f,X,Y,J,i] x = ![f,X,Y,J,i,x] := by
      ext k
      fin_cases k <;> rfl
    rw [hv]
    apply (S.forces_indexedSection _ _ _ _ _ _ _).mpr
    intro z t hts hz a hat hzi
    have hay := S.atomic.mem_mono (hat.trans (hts.trans hsr)) hy
    have haz := S.atomic.mem_mono hat hz
    have hzy := S.injection_one hJ (hat.trans (hts.trans (hsr.trans (hrq.trans hq)))) haz hay hzi
      (S.app_mono (hat.trans (hts.trans hsr)) hyi)
    exact ⟨S.atomic.mem_mono (hat.trans hts) hx,
      (S.app_congr (S.atomic.eq_refl a f) (S.atomic.eq_refl a x) hzy).mpr
        (S.app_mono (hat.trans hts) hxy)⟩
  · refine ⟨q,le_rfl,Name.empty,?_⟩
    have hv : Fin.snoc ![f,X,Y,J,i] (Name.empty : S.Name) = ![f,X,Y,J,i,Name.empty] := by
      ext k
      fin_cases k <;> rfl
    rw [hv]
    apply (S.forces_indexedSection _ _ _ _ _ _ _).mpr
    intro y r hrq hy s hsr hji
    exact (h ⟨s,hsr.trans hrq,y,S.atomic.mem_mono hsr hy,hji⟩).elim

def sectionPart (J Y i x : S.Name) : S.BinaryRelation where
  holds p y z := S.atomic.MemF p y Y ∧ S.App p J y i ∧ S.atomic.EqF p z x
  mono h hh := ⟨S.atomic.mem_mono h hh.1,S.app_mono h hh.2.1,S.atomic.eq_mono h hh.2.2⟩
  regular h := ⟨S.atomic_regular.2 _ _ _ (fun q hq => (h q hq).imp
    (fun _ hr => ⟨hr.1,hr.2.1⟩)),(S.appRelation J).regular (fun q hq => (h q hq).imp
    (fun _ hr => ⟨hr.1,hr.2.2.1⟩)),S.atomic_regular.1 _ _ _ (fun q hq => (h q hq).imp
    (fun _ hr => ⟨hr.1,hr.2.2.2⟩))⟩
  congr hy hz := and_congr (S.atomic.mem_congr hy (S.atomic.eq_refl _ _))
    (and_congr (S.app_congr (S.atomic.eq_refl _ _) hy (S.atomic.eq_refl _ _))
      ⟨fun h => S.atomic.eq_trans (S.atomic.eq_symm hz) h,fun h => S.atomic.eq_trans hz h⟩)

theorem sectionPart_move (J Y i x : S.Name) (g : Γ)
    (hJ : g • J = J) (hY : g • Y = Y) (hi : g • i = i) (hx : g • x = x)
    (p : P) (y z : S.Name) (h : (S.sectionPart J Y i x).holds p y z) :
    (S.sectionPart J Y i x).holds (S.move g p) (g • y) (g • z) := by
  refine ⟨?_,?_,?_⟩
  · simpa only [hY] using (S.mem_symmetry g p y Y).mp h.1
  · simpa only [hJ,hi] using (S.app_symmetry g p J y i).mp h.2.1
  · simpa only [hx] using (S.eq_symmetry g p z x).mp h.2.2

/-- A uniformly supported collection of local preimages gives one internal
injection, including its totality and its absence of extraneous graph entries. -/
theorem section_injection_of_uniform (f X Y J : S.Name) (Ξ : ZFSet.{u}) (c : Ξ → S.Name)
    (H : Subgroup Γ) (hH : H ∈ S.filter) (hX : ∀ g ∈ H, g • X = X)
    (hY : ∀ g ∈ H, g • Y = Y) (hJ : ∀ g ∈ H, g • J = J)
    (hc : ∀ g ∈ H, ∀ i, g • c i = c i) (p : P)
    (hf : S.Forces ![f,X,Y] p (SetLanguage.mapsTo 0 1 2))
    (hj : S.Forces ![J,Y,Name.check Ξ] p (SetLanguage.mapsTo 0 1 2))
    (hs : ∀ i y q, q ≤ p → S.atomic.MemF q y Y → S.App q J y (Name.check i.val) →
      S.atomic.MemF q (c i) X ∧ S.App q f (c i) y) :
    ∃ K : S.Name, S.Forces ![K,Y,X] p (SetLanguage.injection 0 1 2) := by
  let R := BinaryRelation.familyUnion (fun i : Ξ => S.sectionPart J Y (Name.check i.val) (c i))
  have hR : ∀ g ∈ H, ∀ t y z, R.holds t y z → R.holds (S.move g t) (g • y) (g • z) := by
    intro g hg
    exact BinaryRelation.familyUnion_move _ g (fun i => S.sectionPart_move J Y (Name.check i.val)
      (c i) g (hJ g hg) (hY g hg) (Name.smul_check S g i.val) (hc g hg i))
  refine ⟨R.graph Y X H hH hY hX hR,?_⟩
  apply BinaryRelation.graph_injection
  · intro y q hq hy r hrq
    obtain ⟨s,hsr,i,hi,hyi⟩ := S.mapsTo_total hj hq hy r hrq
    obtain ⟨t,hts,a,ha,hia⟩ := (S.mem_check Ξ i s).mp hi s le_rfl
    have hty := S.atomic.mem_mono (hts.trans (hsr.trans hrq)) hy
    have hyai := (S.app_congr (S.atomic.eq_refl t J) (S.atomic.eq_refl t y) hia).mp
      (S.app_mono hts hyi)
    have hval := hs ⟨a,ha⟩ y t (hts.trans (hsr.trans (hrq.trans hq))) hty hyai
    refine ⟨t,hts.trans hsr,c ⟨a,ha⟩,hval.1,?_⟩
    intro b hbt
    exact ⟨b,le_rfl,⟨a,ha⟩,S.atomic.mem_mono hbt hty,S.app_mono hbt hyai,S.atomic.eq_refl b _⟩
  · intro q hq y x z hx hz
    apply S.atomic_regular.1
    intro r hrq
    obtain ⟨s,hsr,i,hy,hyi,hxi⟩ := hx r hrq
    obtain ⟨t,hts,j,_,hyj,hzj⟩ := hz s (hsr.trans hrq)
    have he := S.mapsTo_unique hj (hts.trans (hsr.trans (hrq.trans hq)))
      (S.atomic.mem_mono hts hy) (S.app_mono hts hyi) hyj
    have hij : i = j := Subtype.ext ((S.eq_check_iff i.val j.val t).mp he)
    subst j
    exact ⟨t,hts.trans hsr,S.atomic.eq_trans (S.atomic.eq_mono hts hxi) (S.atomic.eq_symm hzj)⟩
  · intro q hq y z x hy hz
    apply S.atomic_regular.1
    intro r hrq
    obtain ⟨s,hsr,i,hys,hyi,hxi⟩ := hy r hrq
    obtain ⟨t,hts,j,hzt,hzj,hxj⟩ := hz s (hsr.trans hrq)
    have htp := hts.trans (hsr.trans (hrq.trans hq))
    have hy' := hs i y t htp (S.atomic.mem_mono hts hys) (S.app_mono hts hyi)
    have hz' := hs j z t htp hzt hzj
    have hxy := (S.app_congr (S.atomic.eq_refl t f) (S.atomic.eq_mono hts hxi)
      (S.atomic.eq_refl t y)).mpr hy'.2
    have hxz := (S.app_congr (S.atomic.eq_refl t f) hxj (S.atomic.eq_refl t z)).mpr hz'.2
    have hxX := (S.atomic.mem_congr hxj (S.atomic.eq_refl t X)).mpr hz'.1
    exact ⟨t,hts.trans hsr,S.mapsTo_unique hf htp hxX hxy hxz⟩

end
end PartitionConsistency.SetForcingNames.SymmetricSystem

namespace PartitionConsistency.ConcreteSystem
open MonoidConstruction CardinalParameters DiagramForcing SetForcingNames
open ProductForcing SetForcingNames.SymmetricSystem
noncomputable section

/-- In the concrete system, surjections onto a wellorderable target admit
sections densely. The common support is chosen before any fiber values. -/
theorem wellorderable_target_injection (f X Y : S.Name) (p : P)
    (hf : S.Forces ![f,X,Y] p (SetLanguage.surjection 0 1 2))
    (hY : S.Forces ![Y] p (SetLanguage.wellorderable 0)) :
    ∃ q, q ≤ p ∧ ∃ K : S.Name, S.Forces ![K,Y,X] q (SetLanguage.injection 0 1 2) := by
  obtain ⟨r,hrp,β,J,hJ⟩ := S.wellorderable_check_dense Y p hY p le_rfl
  let H := S.tupleStabilizer ![f,X,Y,J]
  let v : β.toZFSet → Fin 5 → S.Name := fun i => ![f,X,Y,J,Name.check i.val]
  have hv : ∀ g ∈ H, ∀ i k, g • v i k = v i k := by
    intro g hg i k
    fin_cases k
    · exact (S.mem_tupleStabilizer _ g).mp hg 0
    · exact (S.mem_tupleStabilizer _ g).mp hg 1
    · exact (S.mem_tupleStabilizer _ g).mp hg 2
    · exact (S.mem_tupleStabilizer _ g).mp hg 3
    · exact Name.smul_check S g i.val
  obtain ⟨s,hsr,G,hG,c,hc,hchoices⟩ := uniform_maximum_dense SetLanguage.indexedSection v H
    (S.tupleStabilizer_mem _) hv r (fun i => S.indexedSection_exists f X Y J
      (Name.check β.toZFSet) (Name.check i.val) r (S.atomic.forceFormula_mono hrp hf) hJ)
  obtain ⟨K,hK⟩ := S.section_injection_of_uniform f X Y J β.toZFSet c (H ⊓ G)
    (S.normal.2.2.1 _ _ (S.tupleStabilizer_mem _) hG)
    (fun g hg => (S.mem_tupleStabilizer _ g).mp hg.1 1)
    (fun g hg => (S.mem_tupleStabilizer _ g).mp hg.1 2)
    (fun g hg => (S.mem_tupleStabilizer _ g).mp hg.1 3)
    (fun g hg => hc g hg.2) s (S.surjection_mapsTo (S.atomic.forceFormula_mono (hsr.trans hrp) hf))
    (S.injection_mapsTo (S.atomic.forceFormula_mono hsr hJ)) (by
      intro i y t hts hy hji
      have hi := hchoices i
      have hv : Fin.snoc (v i) (c i) = ![f,X,Y,J,Name.check i.val,c i] := by
        ext k
        fin_cases k <;> rfl
      rw [hv] at hi
      exact (S.forces_indexedSection _ _ _ _ _ _ _).mp hi y t hts hy t le_rfl hji)
  exact ⟨s,hsr.trans hrp,K,hK⟩

end
end PartitionConsistency.ConcreteSystem

end OAI