import Mathlib
import OAI.SetTheory.PartitionConsistency.Forcing.SymmetricNames

namespace OAI

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

/-- The ordering on literal condition codes, false outside those codes. -/
def codeOrder (a b : ZFSet.{u}) : Prop :=
  ∃ p q : P, S.code p = a ∧ S.code q = b ∧ p ≤ q

theorem codeOrder_codes (p q : P) : S.codeOrder (S.code p) (S.code q) ↔ p ≤ q := by
  constructor
  · rintro ⟨p',q',hp,hq,h⟩
    obtain rfl := S.code_injective hp
    obtain rfl := S.code_injective hq
    exact h
  · exact fun h => ⟨p,q,rfl,rfl,h⟩

theorem codeOrder_symmetry (g : Γ) (a b : ZFSet.{u}) :
    S.codeOrder (S.action.actCode g a) (S.action.actCode g b) ↔ S.codeOrder a b := by
  have forward (g : Γ) (a b : ZFSet.{u}) (h : S.codeOrder a b) :
      S.codeOrder (S.action.actCode g a) (S.action.actCode g b) := by
    obtain ⟨p,q,rfl,rfl,h⟩ := h
    exact ⟨S.move g p, S.move g q, (S.actCode_code g p).symm,
      (S.actCode_code g q).symm, (S.move g).monotone h⟩
  exact ⟨fun h => by simpa only [S.action.actCode_inv_actCode] using forward g⁻¹ _ _ h,
    forward g a b⟩

namespace Name
variable {S}

noncomputable def union (σ : S.Name) : S.Name :=
  ⟨ConditionAction.Name.union S.codeOrder σ.val,
    ConditionAction.Name.union_HS S.normal S.codeOrder S.codeOrder_symmetry σ.hs⟩

end Name

theorem edge_union (σ ν : S.Name) (p : P) :
    ZFSet.pair ν.raw (S.code p) ∈ σ.union.raw ↔ ∃ (χ : S.Name) (c d : P),
    ZFSet.pair χ.raw (S.code c) ∈ σ.raw ∧
    ZFSet.pair ν.raw (S.code d) ∈ χ.raw ∧ p ≤ c ∧ p ≤ d := by
  change ZFSet.pair ν.raw (S.code p) ∈ unionName S.action.conditions S.codeOrder σ.raw ↔ _
  rw [edge_unionName_iff]
  constructor
  · rintro ⟨χ,c',d',hc,hd,_,hp,hq⟩
    obtain ⟨p',c,hp',rfl,hpc⟩ := hp
    obtain rfl := S.code_injective hp'
    obtain ⟨p',d,hp',rfl,hpd⟩ := hq
    obtain rfl := S.code_injective hp'
    exact ⟨σ.child hc,c,d,hc,hd,hpc,hpd⟩
  · rintro ⟨χ,c,d,hc,hd,hpc,hpd⟩
    exact ⟨χ.raw,S.code c,S.code d,hc,hd,S.code_mem p,
      (S.codeOrder_codes p c).mpr hpc,(S.codeOrder_codes p d).mpr hpd⟩

theorem mem_union (σ ν : S.Name) (p : P) : S.atomic.MemF p ν σ.union ↔
    ∀ q, q ≤ p → ∃ r, r ≤ q ∧ ∃ χ : S.Name,
      S.atomic.MemF r χ σ ∧ S.atomic.MemF r ν χ := by
  constructor
  · intro h q hqp
    obtain ⟨r,hrq,τ,c,he,hrc,heq⟩ := (S.mem_iff.mp h) q hqp
    obtain ⟨χ,a,b,ha,hb,hca,hcb⟩ := (S.edge_union σ τ c).mp he
    refine ⟨r,hrq,χ,S.mem_of_edge ha (hrc.trans hca),?_⟩
    exact (S.atomic.mem_congr heq (S.atomic.eq_refl r χ)).mpr
      (S.mem_of_edge hb (hrc.trans hcb))
  · intro h
    apply S.mem_iff.mpr
    intro q hqp
    obtain ⟨r,hrq,χ,hχ,hν⟩ := h q hqp
    obtain ⟨s,hsr,τ,c,hτ,hsc,heq⟩ := (S.mem_iff.mp hχ) r le_rfl
    have hντ : S.atomic.MemF s ν τ :=
      (S.atomic.mem_congr (S.atomic.eq_refl s ν) heq).mp (S.atomic.mem_mono hsr hν)
    obtain ⟨t,hts,η,d,hη,htd,heq'⟩ := (S.mem_iff.mp hντ) s le_rfl
    exact ⟨t,hts.trans (hsr.trans hrq),η,t,
      (S.edge_union σ η t).mpr ⟨τ,c,d,hτ,hη,hts.trans hsc,htd⟩,le_rfl,heq'⟩

/-- The Union axiom for arbitrary HS input names. -/
theorem forces_union (p : P) : S.Forces Fin.elim0 p SetLanguage.union := by
  simp only [Forces, SetLanguage.union, S.atomic.forceFormula_all S.atomic_regular,
    S.atomic.forceFormula_imp S.atomic_regular, Formula.iff,
    ForcingQuotient.AtomicData.forceFormula_ex, ForcingQuotient.AtomicData.forceFormula_conj,
    ForcingQuotient.AtomicData.forceFormula_mem]
  intro σ q hqp
  refine ⟨q,le_rfl,σ.union,?_⟩
  intro ν
  exact ⟨fun r _ => (S.mem_union σ ν r).mp, fun r _ => (S.mem_union σ ν r).mpr⟩

end PartitionConsistency.SetForcingNames.SymmetricSystem

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

@[simp] theorem code_top_fixed (g : Γ) : S.action.actCode g (S.code ⊤) = S.code ⊤ := by
  rw [S.actCode_code, (S.move g).map_top]

namespace Name
variable {S}

noncomputable def pair (σ τ : S.Name) : S.Name :=
  ⟨ConditionAction.Name.pair (S.code_mem ⊤) σ.val τ.val,
    ConditionAction.Name.pair_HS S.normal (S.code_mem ⊤) S.code_top_fixed σ.hs τ.hs⟩

noncomputable def check (x : ZFSet.{u}) : S.Name :=
  ⟨ConditionAction.Name.check (S.code_mem ⊤) x,
    ConditionAction.Name.check_HS S.normal.1 (S.code_mem ⊤) S.code_top_fixed x⟩

@[simp] theorem check_raw (x : ZFSet.{u}) : (check (S := S) x).raw = checkName (S.code ⊤) x := rfl

@[simp] theorem check_empty : check (S := S) ∅ = empty := by
  apply ext
  apply ZFSet.ext
  intro z
  simp [check_raw, mem_checkName_iff, empty_val]

end Name

theorem edge_pair (σ τ ν : S.Name) (c : P) :
    ZFSet.pair ν.raw (S.code c) ∈ (σ.pair τ).raw ↔ (ν = σ ∨ ν = τ) ∧ c = ⊤ := by
  change ZFSet.pair ν.raw (S.code c) ∈ pairName (S.code ⊤) σ.raw τ.raw ↔ _
  rw [edge_pairName_iff]
  have hinj : Function.Injective (Name.raw : S.Name → ZFSet.{u}) := fun _ _ => Name.ext
  simp only [hinj.eq_iff, S.code_injective.eq_iff]

theorem mem_pair (σ τ ν : S.Name) (p : P) : S.atomic.MemF p ν (σ.pair τ) ↔
    ∀ q, q ≤ p → ∃ r, r ≤ q ∧ (S.atomic.EqF r ν σ ∨ S.atomic.EqF r ν τ) := by
  constructor
  · intro h q hqp
    obtain ⟨r,hrq,η,c,he,_,heq⟩ := (S.mem_iff.mp h) q hqp
    obtain ⟨hη | hη,_⟩ := (S.edge_pair σ τ η c).mp he
    · exact ⟨r,hrq,Or.inl (hη ▸ heq)⟩
    · exact ⟨r,hrq,Or.inr (hη ▸ heq)⟩
  · intro h
    apply S.mem_iff.mpr
    intro q hqp
    obtain ⟨r,hrq,heq | heq⟩ := h q hqp
    · exact ⟨r,hrq,σ,⊤,(S.edge_pair σ τ σ ⊤).mpr ⟨Or.inl rfl,rfl⟩,le_top,heq⟩
    · exact ⟨r,hrq,τ,⊤,(S.edge_pair σ τ τ ⊤).mpr ⟨Or.inr rfl,rfl⟩,le_top,heq⟩

/-- The Pairing axiom, with the standard largest-condition name. -/
theorem forces_pairing (p : P) : S.Forces Fin.elim0 p SetLanguage.pairing := by
  simp only [Forces, SetLanguage.pairing, SetLanguage.unorderedPair, Formula.iff,
    S.atomic.forceFormula_rename S.atomic_regular, S.atomic.forceFormula_all S.atomic_regular,
    S.atomic.forceFormula_imp S.atomic_regular, ForcingQuotient.AtomicData.forceFormula_conj,
    ForcingQuotient.AtomicData.forceFormula_disj, ForcingQuotient.AtomicData.forceFormula_ex,
    ForcingQuotient.AtomicData.forceFormula_mem, ForcingQuotient.AtomicData.forceFormula_equal]
  intro σ τ q hqp
  refine ⟨q,le_rfl,σ.pair τ,?_⟩
  intro ν
  exact ⟨fun r _ => (S.mem_pair σ τ ν r).mp, fun r _ => (S.mem_pair σ τ ν r).mpr⟩

theorem mem_check (x : ZFSet.{u}) (ν : S.Name) (p : P) :
    S.atomic.MemF p ν (Name.check x) ↔
      ∀ q, q ≤ p → ∃ r, r ≤ q ∧ ∃ y ∈ x, S.atomic.EqF r ν (Name.check y) := by
  constructor
  · intro h q hqp
    obtain ⟨r,hrq,τ,c,he,_,heq⟩ := (S.mem_iff.mp h) q hqp
    obtain ⟨y,hy,hτ,_⟩ := edge_checkName_iff.mp he
    have hyτ : Name.check y = τ := Name.ext hτ
    exact ⟨r,hrq,y,hy,hyτ ▸ heq⟩
  · intro h
    apply S.mem_iff.mpr
    intro q hqp
    obtain ⟨r,hrq,y,hy,heq⟩ := h q hqp
    exact ⟨r,hrq,Name.check y,⊤,edge_checkName_iff.mpr ⟨y,hy,rfl,rfl⟩,le_top,heq⟩

theorem check_mem_of_mem {x y : ZFSet.{u}} (h : y ∈ x) (p : P) :
    S.atomic.MemF p (Name.check y) (Name.check x) :=
  S.mem_of_edge (edge_checkName_iff.mpr ⟨y,h,rfl,rfl⟩) le_top

/-- The check name of a ground successor is its internal successor. -/
theorem check_successor (x : ZFSet.{u}) (ν : S.Name) (p : P) :
    S.atomic.MemF p ν (Name.check (insert x x)) ↔
      ∀ q, q ≤ p → ∃ r, r ≤ q ∧
        (S.atomic.MemF r ν (Name.check x) ∨ S.atomic.EqF r ν (Name.check x)) := by
  constructor
  · intro h q hqp
    obtain ⟨r,hrq,y,hy,heq⟩ := (S.mem_check _ ν p).mp h q hqp
    rcases ZFSet.mem_insert_iff.mp hy with rfl | hy
    · exact ⟨r,hrq,Or.inr heq⟩
    · exact ⟨r,hrq,Or.inl ((S.atomic.mem_congr heq (S.atomic.eq_refl r (Name.check x))).mpr
        (S.check_mem_of_mem hy r))⟩
  · intro h
    apply (S.mem_check _ ν p).mpr
    intro q hqp
    obtain ⟨r,hrq,hm | he⟩ := h q hqp
    · obtain ⟨s,hsr,y,hy,heq⟩ := (S.mem_check x ν r).mp hm r le_rfl
      exact ⟨s,hsr.trans hrq,y,ZFSet.mem_insert_iff.mpr (Or.inr hy),heq⟩
    · exact ⟨r,hrq,x,ZFSet.mem_insert_iff.mpr (Or.inl rfl),he⟩

/-- The Infinity witness is the literal check-name of the ground natural numbers. -/
theorem forces_infinity (p : P) : S.Forces Fin.elim0 p SetLanguage.infinity := by
  simp only [Forces, SetLanguage.infinity, SetLanguage.empty, SetLanguage.successor,
    S.atomic.forceFormula_rename S.atomic_regular, S.atomic.forceFormula_all S.atomic_regular,
    S.atomic.forceFormula_imp S.atomic_regular, Formula.iff,
    ForcingQuotient.AtomicData.forceFormula_conj, ForcingQuotient.AtomicData.forceFormula_ex,
    ForcingQuotient.AtomicData.forceFormula_disj,
    ForcingQuotient.AtomicData.forceFormula_mem, ForcingQuotient.AtomicData.forceFormula_equal,
    ForcingQuotient.AtomicData.forceFormula_bot]
  intro q hqp
  refine ⟨q,le_rfl,Name.check ZFSet.omega,?_,?_⟩
  · intro r hrq
    refine ⟨r,le_rfl,Name.check ∅,S.check_mem_of_mem ZFSet.omega_zero r,?_⟩
    intro ν t htr ht
    change S.atomic.MemF t ν (Name.check ∅) at ht
    exact S.not_mem_empty t ν (by simpa only [Name.check_empty] using ht)
  · intro ν r hrq hν t htr
    obtain ⟨s,hst,x,hx,heq⟩ := (S.mem_check ZFSet.omega ν r).mp hν t htr
    refine ⟨s,hst,Name.check (insert x x),S.check_mem_of_mem (ZFSet.omega_succ hx) s,?_⟩
    intro ρ
    constructor
    · intro a has ha b hba
      obtain ⟨c,hcb,hc | hc⟩ := (S.check_successor x ρ a).mp ha b hba
      · exact ⟨c,hcb,Or.inl ((S.atomic.mem_congr (S.atomic.eq_refl c ρ)
          (S.atomic.eq_mono (hcb.trans (hba.trans has)) heq)).mpr hc)⟩
      · exact ⟨c,hcb,Or.inr (S.atomic.eq_trans hc
          (S.atomic.eq_symm (S.atomic.eq_mono (hcb.trans (hba.trans has)) heq)))⟩
    · intro a has ha
      apply (S.check_successor x ρ a).mpr
      intro b hba
      obtain ⟨c,hcb,hc | hc⟩ := ha b hba
      · exact ⟨c,hcb,Or.inl ((S.atomic.mem_congr (S.atomic.eq_refl c ρ)
          (S.atomic.eq_mono (hcb.trans (hba.trans has)) heq)).mp hc)⟩
      · exact ⟨c,hcb,Or.inr (S.atomic.eq_trans hc
          (S.atomic.eq_mono (hcb.trans (hba.trans has)) heq))⟩

end PartitionConsistency.SetForcingNames.SymmetricSystem



namespace PartitionConsistency.SetForcingNames.SymmetricSystem
universe u v w t
variable {P : Type w} [Preorder P] {Γ : Type v} [Group Γ]
variable (S : SymmetricSystem.{u} P Γ)

/-- The same entry-permutation argument records the particular fixing subgroup,
not merely that some subgroup in the filter fixes the collected name. -/
theorem collectName_fixed {ι : Type t} [Small.{u} ι] (f : ι → S.Name) (R : ι → P → Prop)
    (H : Subgroup Γ)
    (permutes : ∀ g ∈ H, ∀ i p, R i p → ∃ j,
      f j = g • f i ∧ R j (S.move g p)) (g : Γ) (hg : g ∈ H) :
    g • S.collectName f R = S.collectName f R := by
  have hsub (g : Γ) (hg : g ∈ H) :
      (g • S.collectName f R).val ⊆ (S.collectName f R).val := by
    intro z hz
    obtain ⟨ν,c,he,rfl⟩ := mem_mapConditions_iff.mp hz
    obtain ⟨i,p,hR,rfl,rfl⟩ := (S.edge_collectRaw f R ν c).mp he
    obtain ⟨j,hj,hRj⟩ := permutes g hg i p hR
    apply (S.mem_collectRaw f R _).mpr
    refine ⟨j, S.move g p, hRj, ?_⟩
    rw [hj, Name.smul_val, S.actCode_code]
  apply ConditionAction.Name.ext
  apply le_antisymm (hsub g hg)
  have hi := mapConditions_mono (S.action.actCode g) (hsub g⁻¹ (H.inv_mem hg))
  change (g • (g⁻¹ • S.collectName f R)).val ⊆ (g • S.collectName f R).val at hi
  simpa only [smul_inv_smul] using hi

def SubsetF (p : P) (σ τ : S.Name) : Prop :=
  ∀ ν : S.Name, ∀ q, q ≤ p → S.atomic.MemF q ν σ → S.atomic.MemF q ν τ

theorem forces_subset {n} (v : Fin n → S.Name) (p : P) (a b : Fin n) :
    S.Forces v p (SetLanguage.subset a b) ↔ S.SubsetF p (v a) (v b) := by
  simp only [Forces, SetLanguage.subset, S.atomic.forceFormula_rename S.atomic_regular,
    S.atomic.forceFormula_all S.atomic_regular, S.atomic.forceFormula_imp S.atomic_regular,
    ForcingQuotient.AtomicData.forceFormula_mem]
  rfl

theorem subset_mono {p q : P} {σ τ : S.Name} (h : q ≤ p) (hsub : S.SubsetF p σ τ) :
    S.SubsetF q σ τ := fun ν r hr => hsub ν r (hr.trans h)

theorem subset_of_dense {p : P} {σ τ : S.Name}
    (h : ∀ q, q ≤ p → ∃ r, r ≤ q ∧ S.SubsetF r σ τ) : S.SubsetF p σ τ := by
  intro ν q hqp hν
  apply S.atomic_regular.2 q ν τ
  intro r hrq
  obtain ⟨s,hsr,hs⟩ := h r (hrq.trans hqp)
  exact ⟨s,hsr,hs ν s le_rfl (S.atomic.mem_mono (hsr.trans hrq) hν)⟩

theorem subset_congr {p : P} {σ σ' τ τ' : S.Name}
    (hσ : S.atomic.EqF p σ σ') (hτ : S.atomic.EqF p τ τ') :
    S.SubsetF p σ τ ↔ S.SubsetF p σ' τ' := by
  constructor
  · intro h ν q hqp hν
    exact (S.atomic.mem_congr (S.atomic.eq_refl q ν) (S.atomic.eq_mono hqp hτ)).mp
      (h ν q hqp ((S.atomic.mem_congr (S.atomic.eq_refl q ν) (S.atomic.eq_mono hqp hσ)).mpr hν))
  · intro h ν q hqp hν
    exact (S.atomic.mem_congr (S.atomic.eq_refl q ν) (S.atomic.eq_mono hqp hτ)).mpr
      (h ν q hqp ((S.atomic.mem_congr (S.atomic.eq_refl q ν) (S.atomic.eq_mono hqp hσ)).mp hν))

theorem subset_symmetry (g : Γ) (p : P) (σ τ : S.Name) :
    S.SubsetF p σ τ ↔ S.SubsetF (S.move g p) (g • σ) (g • τ) := by
  have h := S.forces_symmetry g (SetLanguage.subset 0 1) ![σ,τ] p
  simpa only [S.forces_subset, Matrix.cons_val_zero, Matrix.cons_val_one] using h

/-- All possible immediate pairs over the domain of a particular name form a
set. This is a bound on normalizations of subsets, not on all HS names. -/
noncomputable def subsetBound (σ : S.Name) : ZFSet.{u} :=
  S.collectRaw (fun i : Edges σ.raw => σ.child i.property) (fun _ _ => True)

theorem subsetBound_fixed (σ : S.Name) (g : Γ) (hg : g • σ = σ) :
    mapConditions (S.action.actCode g) (S.subsetBound σ) = S.subsetBound σ := by
  have hp : ∀ h ∈ MulAction.stabilizer Γ σ.val, ∀ (i : Edges σ.raw) (p : P),
      True → ∃ j : Edges σ.raw, σ.child j.property = h • σ.child i.property ∧ True := by
    intro h hh i p _
    have ht : h • σ = σ := Subtype.ext hh
    have he := S.entry_permute h σ i
    rw [ht] at he
    obtain ⟨j,hj⟩ := he
    exact ⟨j,hj,True.intro⟩
  exact congrArg (fun ν : S.action.Name => ν.val)
    (S.collectName_fixed (fun i : Edges σ.raw => σ.child i.property) (fun _ _ => True)
      (MulAction.stabilizer Γ σ.val) hp g (congrArg Subtype.val hg))

/-- The actual HS candidates inside the small set of normalization codes. -/
def PowerCandidate (σ : S.Name) := {ν : S.Name // ν.raw ⊆ S.subsetBound σ}

instance (σ : S.Name) : Small.{u} (S.PowerCandidate σ) := by
  apply small_of_injective (f := fun ν : S.PowerCandidate σ =>
    (⟨ν.val.raw,ZFSet.mem_powerset.mpr ν.property⟩ : (S.subsetBound σ).powerset))
  intro ν τ h
  exact Subtype.ext (Name.ext (congrArg Subtype.val h))

noncomputable def normalize (σ ν : S.Name) : S.Name :=
  S.separate σ ![ν] (.mem 1 0)

theorem mem_normalize (σ ν τ : S.Name) (p : P) :
    S.atomic.MemF p τ (S.normalize σ ν) ↔ S.atomic.MemF p τ σ ∧ S.atomic.MemF p τ ν :=
  S.mem_separate σ ![ν] (.mem 1 0) τ p

theorem normalize_bounded (σ ν : S.Name) : (S.normalize σ ν).raw ⊆ S.subsetBound σ := by
  intro z hz
  change z ∈ S.collectRaw (fun i : Edges σ.raw => σ.child i.property)
    (S.separationTest σ ![ν] (.mem 1 0)) at hz
  obtain ⟨i,p,_,he⟩ := (S.mem_collectRaw _ _ _).mp hz
  exact (S.mem_collectRaw _ _ _).mpr ⟨i,p,True.intro,he⟩

theorem normalize_eq {p : P} (σ ν : S.Name) (h : S.SubsetF p ν σ) :
    S.atomic.EqF p ν (S.normalize σ ν) := by
  apply S.eq_of_same_members
  intro τ q hqp
  rw [S.mem_normalize]
  exact ⟨fun hτ => ⟨h τ q hqp hτ,hτ⟩, And.right⟩

theorem powerCandidate_permute (σ : S.Name) :
    ∀ g ∈ MulAction.stabilizer Γ σ.val, ∀ (i : S.PowerCandidate σ) p,
      S.SubsetF p i.val σ → ∃ j : S.PowerCandidate σ,
        j.val = g • i.val ∧ S.SubsetF (S.move g p) j.val σ := by
  intro g hg i p hi
  have hσ : g • σ = σ := Subtype.ext hg
  have hbound : (g • i.val).raw ⊆ S.subsetBound σ := by
    rw [Name.smul_val]
    have hb := mapConditions_mono (S.action.actCode g) i.property
    simpa only [S.subsetBound_fixed σ g hσ] using hb
  refine ⟨⟨g • i.val,hbound⟩,rfl,?_⟩
  simpa only [hσ] using (S.subset_symmetry g p i.val σ).mp hi

/-- The power-set name uses every HS normalized subset candidate and the
conditions which force that candidate to be a subset. -/
noncomputable def power (σ : S.Name) : S.Name :=
  S.collect (fun i : S.PowerCandidate σ => i.val) (fun i p => S.SubsetF p i.val σ)
    (MulAction.stabilizer Γ σ.val) σ.hs.symmetric (S.powerCandidate_permute σ)

theorem edge_power (σ ν : S.Name) (p : P) :
    ZFSet.pair ν.raw (S.code p) ∈ (S.power σ).raw ↔
      ν.raw ⊆ S.subsetBound σ ∧ S.SubsetF p ν σ := by
  change ZFSet.pair ν.raw (S.code p) ∈
    S.collectRaw (fun i : S.PowerCandidate σ => i.val) (fun i p => S.SubsetF p i.val σ) ↔ _
  rw [S.edge_collectRaw]
  constructor
  · rintro ⟨i,q,hi,hν,hq⟩
    obtain rfl := S.code_injective hq
    have heq : i.val = ν := Name.ext hν
    exact ⟨hν ▸ i.property,heq ▸ hi⟩
  · rintro ⟨hb,hs⟩
    exact ⟨⟨ν,hb⟩,p,hs,rfl,rfl⟩

theorem mem_power (σ ν : S.Name) (p : P) :
    S.atomic.MemF p ν (S.power σ) ↔ S.SubsetF p ν σ := by
  constructor
  · intro h
    apply S.subset_of_dense
    intro q hqp
    obtain ⟨r,hrq,τ,c,he,hrc,heq⟩ := (S.mem_iff.mp h) q hqp
    have hτ := S.subset_mono hrc ((S.edge_power σ τ c).mp he).2
    exact ⟨r,hrq,(S.subset_congr heq (S.atomic.eq_refl r σ)).mpr hτ⟩
  · intro h
    have heq := S.normalize_eq σ ν h
    have hs : S.SubsetF p (S.normalize σ ν) σ :=
      (S.subset_congr heq (S.atomic.eq_refl p σ)).mp h
    exact (S.atomic.mem_congr heq (S.atomic.eq_refl p (S.power σ))).mpr
      (S.mem_of_edge ((S.edge_power σ (S.normalize σ ν) p).mpr
        ⟨S.normalize_bounded σ ν,hs⟩) le_rfl)

/-- Power Set with quantification over every HS name, including subsets at
arbitrarily high name ranks. -/
theorem forces_powerSet (p : P) : S.Forces Fin.elim0 p SetLanguage.powerSet := by
  simp only [Forces, SetLanguage.powerSet, S.atomic.forceFormula_all S.atomic_regular,
    S.atomic.forceFormula_imp S.atomic_regular, Formula.iff,
    ForcingQuotient.AtomicData.forceFormula_ex, ForcingQuotient.AtomicData.forceFormula_conj,
    ForcingQuotient.AtomicData.forceFormula_mem]
  intro σ q hqp
  refine ⟨q,le_rfl,S.power σ,?_⟩
  intro ν
  simp only [S.forces_subset]
  exact ⟨fun r _ => (S.mem_power σ ν r).mp, fun r _ => (S.mem_power σ ν r).mpr⟩

end PartitionConsistency.SetForcingNames.SymmetricSystem

end OAI