import Mathlib
import OAI.SetTheory.PartitionConsistency.Forcing.SymmetricSets

namespace OAI

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

abbrev RelF {n} (v : Fin n → S.Name) (φ : Formula (n+2)) (p : P)
    (x y : S.Name) : Prop := S.Forces (Fin.snoc (Fin.snoc v x) y) p φ

theorem forces_relation {n m} (φ : Formula (n+2)) (r : Fin n → Fin m)
    (x y : Fin m) (v : Fin m → S.Name) (p : P) :
    S.Forces v p (SetLanguage.relation φ r x y) ↔ S.RelF (v ∘ r) φ p (v x) (v y) := by
  rw [SetLanguage.relation, Forces, S.atomic.forceFormula_rename S.atomic_regular]
  have h : v ∘ Fin.lastCases y (Fin.lastCases x r) =
      Fin.snoc (Fin.snoc (v ∘ r) (v x)) (v y) := by
    funext i
    refine Fin.lastCases ?_ (fun j => ?_) i
    · simp
    · refine Fin.lastCases ?_ (fun k => ?_) j <;> simp [Function.comp_def]
  rw [h]

theorem rel_left_congr {n} (v : Fin n → S.Name) (φ : Formula (n+2))
    {p : P} {x x' : S.Name} (y : S.Name) (heq : S.atomic.EqF p x x') :
    S.RelF v φ p x y ↔ S.RelF v φ p x' y := by
  apply S.atomic.forceFormula_tuple_congr
  intro i
  refine Fin.lastCases ?_ (fun j => ?_) i
  · simpa using S.atomic.eq_refl p y
  · refine Fin.lastCases ?_ (fun k => ?_) j
    · simpa using heq
    · simpa using S.atomic.eq_refl p (v k)

/-- A small index set of precisely the domain-entry/condition pairs for which
there is a local symmetric witness. -/
def WitnessIndex {n} (σ : S.Name) (v : Fin n → S.Name) (φ : Formula (n+2)) :=
  {i : Edges σ.raw × P // ∃ η : S.Name, S.RelF v φ i.2 (σ.child i.1.property) η}

instance {n} (σ : S.Name) (v : Fin n → S.Name) (φ : Formula (n+2)) :
    Small.{u} (S.WitnessIndex σ v φ) := by
  let := S.small_conditions
  unfold WitnessIndex
  infer_instance

noncomputable def chosenWitness {n} (σ : S.Name) (v : Fin n → S.Name) (φ : Formula (n+2))
    (i : S.WitnessIndex σ v φ) : S.Name := Classical.choose i.property

theorem chosenWitness_spec {n} (σ : S.Name) (v : Fin n → S.Name) (φ : Formula (n+2))
    (i : S.WitnessIndex σ v φ) :
    S.RelF v φ i.val.2 (σ.child i.val.1.property) (S.chosenWitness σ v φ i) :=
  Classical.choose_spec i.property

section SmallGroup
variable [Small.{u} Γ]

/-- An orbit-closed bound for one Replacement problem. Instead of a uniform
name-rank cutoff, take the whole set-group orbit of the ground-chosen local
witnesses. This set is invariant and is still small. No symmetric maximum
principle, global rank cutoff, or on-condition selection is used. -/
noncomputable def replacementBound {n} (σ : S.Name) (v : Fin n → S.Name)
    (φ : Formula (n+2)) : S.Name :=
  S.collect (fun z : Γ × S.WitnessIndex σ v φ => z.1 • S.chosenWitness σ v φ z.2)
    (fun _ _ => True) ⊤ S.normal.1 (by
      intro h _ z p _
      exact ⟨(h*z.1,z.2),mul_smul h z.1 _,True.intro⟩)

theorem witness_in_bound {n} (σ : S.Name) (v : Fin n → S.Name) (φ : Formula (n+2))
    (i : S.WitnessIndex σ v φ) (p : P) :
    S.atomic.MemF p (S.chosenWitness σ v φ i) (S.replacementBound σ v φ) := by
  apply S.mem_of_edge (c := p) ?_ le_rfl
  change ZFSet.pair (S.chosenWitness σ v φ i).raw (S.code p) ∈ S.collectRaw
    (fun z : Γ × S.WitnessIndex σ v φ => z.1 • S.chosenWitness σ v φ z.2) (fun _ _ => True)
  apply (S.edge_collectRaw _ _ _ _).mpr
  exact ⟨(1,i),p,True.intro,by simp,rfl⟩

theorem bounded_local_witness {n} (σ : S.Name) (v : Fin n → S.Name) (φ : Formula (n+2))
    (i : Edges σ.raw) (p : P) (hi : ∃ η, S.RelF v φ p (σ.child i.property) η) :
    ∃ η : S.Name, S.RelF v φ p (σ.child i.property) η ∧
      S.atomic.MemF p η (S.replacementBound σ v φ) := by
  let j : S.WitnessIndex σ v φ := ⟨(i,p),hi⟩
  exact ⟨S.chosenWitness σ v φ j,S.chosenWitness_spec σ v φ j,S.witness_in_bound σ v φ j p⟩

/-- The dense local meaning of `∃x∈σ, φ(x,y)`. -/
def ImageF {n} (σ : S.Name) (v : Fin n → S.Name) (φ : Formula (n+2))
    (p : P) (ν : S.Name) : Prop :=
  ∀ q, q ≤ p → ∃ r, r ≤ q ∧ ∃ x : S.Name, S.atomic.MemF r x σ ∧ S.RelF v φ r x ν

/-- Ordinary internal single-valuedness, expressed via forcing at every
stronger condition. -/
def SingleValuedF {n} (σ : S.Name) (v : Fin n → S.Name) (φ : Formula (n+2)) (p : P) : Prop :=
  ∀ x y z : S.Name, ∀ q, q ≤ p → S.atomic.MemF q x σ →
    S.RelF v φ q x y → S.RelF v φ q x z → S.atomic.EqF q y z

theorem image_in_bound {n} (σ : S.Name) (v : Fin n → S.Name) (φ : Formula (n+2))
    {p : P} (hfunc : S.SingleValuedF σ v φ p) (ν : S.Name) (himage : S.ImageF σ v φ p ν) :
    S.atomic.MemF p ν (S.replacementBound σ v φ) := by
  apply S.atomic_regular.2
  intro q hqp
  obtain ⟨r,hrq,x,hx,hφ⟩ := himage q hqp
  obtain ⟨s,hsr,τ,c,he,hsc,heq⟩ := (S.mem_iff.mp hx) r le_rfl
  let i : Edges σ.raw := ⟨(τ.raw,S.code c),he⟩
  have hi : σ.child i.property = τ := Name.ext rfl
  have hφ' : S.RelF v φ s τ ν := (S.rel_left_congr v φ ν heq).mp
    (S.atomic.forceFormula_mono hsr hφ)
  obtain ⟨η,hηφ,hηB⟩ := S.bounded_local_witness σ v φ i s ⟨ν,by simpa only [hi] using hφ'⟩
  rw [hi] at hηφ
  have hνη := hfunc τ ν η s (hsr.trans (hrq.trans hqp)) (S.mem_of_edge he hsc) hφ' hηφ
  exact ⟨s,hsr.trans hrq,(S.atomic.mem_congr hνη
    (S.atomic.eq_refl s (S.replacementBound σ v φ))).mpr hηB⟩

/-- The image predicate, with the set-domain as one extra parameter, retaining
all quantifiers of the original formula. -/
def imageFormula {n} (φ : Formula (n+2)) : Formula (n+2) :=
  Formula.ex ((Formula.mem (Fin.last (n+2)) (Fin.last n).castSucc.castSucc).conj
    (SetLanguage.relation φ (fun i => i.castSucc.castSucc.castSucc)
      (Fin.last (n+2)) (Fin.last (n+1)).castSucc))

omit [Small.{u} Γ] in
theorem forces_imageFormula {n} (σ : S.Name) (v : Fin n → S.Name)
    (φ : Formula (n+2)) (ν : S.Name) (p : P) :
    S.Forces (Fin.snoc (Fin.snoc v σ) ν) p (imageFormula φ) ↔ S.ImageF σ v φ p ν := by
  simp only [Forces, imageFormula, ForcingQuotient.AtomicData.forceFormula_ex,
    ForcingQuotient.AtomicData.forceFormula_conj, ForcingQuotient.AtomicData.forceFormula_mem,
    S.forces_relation, Fin.snoc_last, Fin.snoc_castSucc]
  have h (x : S.Name) : Fin.snoc (Fin.snoc (Fin.snoc v σ) ν) x ∘
      (fun i => i.castSucc.castSucc.castSucc) = v := by funext i; simp
  simp only [h]
  rfl

noncomputable def replacementImage {n} (σ : S.Name) (v : Fin n → S.Name)
    (φ : Formula (n+2)) : S.Name :=
  S.separate (S.replacementBound σ v φ) (Fin.snoc v σ) (imageFormula φ)

theorem mem_replacementImage {n} (σ : S.Name) (v : Fin n → S.Name)
    (φ : Formula (n+2)) {p : P} (hfunc : S.SingleValuedF σ v φ p) (ν : S.Name) :
    S.atomic.MemF p ν (S.replacementImage σ v φ) ↔ S.ImageF σ v φ p ν := by
  rw [replacementImage, S.mem_separate, S.forces_imageFormula]
  exact ⟨And.right,fun h => ⟨S.image_in_bound σ v φ hfunc ν h,h⟩⟩

/-- The antecedent of a Replacement instance: totality with local unique
witnesses, exactly as supplied by the existential forcing clause. -/
def TotalFunctionalF {n} (σ : S.Name) (v : Fin n → S.Name) (φ : Formula (n+2)) (p : P) : Prop :=
  ∀ x : S.Name, ∀ q, q ≤ p → S.atomic.MemF q x σ → ∀ r, r ≤ q →
    ∃ s, s ≤ r ∧ ∃ y : S.Name, S.RelF v φ s x y ∧
      ∀ z : S.Name, ∀ t, t ≤ s → S.RelF v φ t x z → S.atomic.EqF t z y

omit [Small.{u} Γ] in
theorem singleValued_of_totalFunctional {n} (σ : S.Name) (v : Fin n → S.Name)
    (φ : Formula (n+2)) {p : P} (h : S.TotalFunctionalF σ v φ p) :
    S.SingleValuedF σ v φ p := by
  intro x y z q hqp hx hy hz
  apply S.atomic_regular.1
  intro r hrq
  obtain ⟨s,hsr,η,_,hη⟩ := h x q hqp hx r hrq
  exact ⟨s,hsr,S.atomic.eq_trans (hη y s le_rfl (S.atomic.forceFormula_mono (hsr.trans hrq) hy))
    (S.atomic.eq_symm (hη z s le_rfl (S.atomic.forceFormula_mono (hsr.trans hrq) hz)))⟩

/-- Every full Replacement instance is forced. The bound depends on the
particular domain, formula, and parameter tuple, and not on a prechosen class
of name ranks. -/
theorem forces_replacement {n} (φ : Formula (n+2)) (p : P) :
    S.Forces Fin.elim0 p (SetLanguage.replacement φ) := by
  unfold SetLanguage.replacement
  rw [Forces, S.atomic.forceFormula_close S.atomic_regular]
  simp only [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, ForcingQuotient.AtomicData.forceFormula_equal,
    S.forces_relation, Fin.snoc_last, Fin.snoc_castSucc]
  have h3 (v : Fin n → S.Name) (a b c : S.Name) :
      Fin.snoc (Fin.snoc (Fin.snoc v a) b) c ∘ (fun i => i.castSucc.castSucc.castSucc) = v := by
    funext i
    simp
  have h4 (v : Fin n → S.Name) (a b c d : S.Name) :
      Fin.snoc (Fin.snoc (Fin.snoc (Fin.snoc v a) b) c) d ∘
        (fun i => i.castSucc.castSucc.castSucc.castSucc) = v := by
    funext i
    simp
  simp only [h3,h4]
  intro v σ q hqp h r hrq
  change S.TotalFunctionalF σ v φ q at h
  have hfunc := S.singleValued_of_totalFunctional σ v φ h
  have hf {t : P} (htq : t ≤ q) : S.SingleValuedF σ v φ t :=
    fun x y z a hat => hfunc x y z a (hat.trans htq)
  refine ⟨r,le_rfl,S.replacementImage σ v φ,?_⟩
  intro ν
  exact ⟨fun t htr => (S.mem_replacementImage σ v φ (hf (htr.trans hrq)) ν).mp,
    fun t htr => (S.mem_replacementImage σ v φ (hf (htr.trans hrq)) ν).mpr⟩

end SmallGroup
end PartitionConsistency.SetForcingNames.SymmetricSystem



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

/-- Full ZF in the concrete hereditary-symmetry interpretation. The quantifier
domain is the unbounded class of all HS names. Each schema instance is proved
by its own actual set-name, including unrestricted Separation and Replacement. -/
theorem forces_ZF (p : P) : ∀ φ ∈ SetLanguage.ZF, S.Forces Fin.elim0 p φ := by
  intro φ hφ
  cases hφ with
  | extensionality => exact S.forces_extensionality p
  | emptySet => exact S.forces_emptySet p
  | pairing => exact S.forces_pairing p
  | union => exact S.forces_union p
  | powerSet => exact S.forces_powerSet p
  | infinity => exact S.forces_infinity p
  | foundation => exact S.forces_foundation p
  | separation φ => exact S.forces_separation φ p
  | replacement φ => exact S.forces_replacement φ p

end PartitionConsistency.SetForcingNames.SymmetricSystem

end OAI