import Mathlib
import OAI.SetTheory.PartitionConsistency.Models.ClassFibers
import OAI.SetTheory.PartitionConsistency.Forcing.ChoiceFailure

namespace OAI

/-! ## Antichain -/

namespace PartitionConsistency.ForcingQuotient
universe u
noncomputable section
variable {P : Type u} [Preorder P]

/-- Every set of forcing conditions has a maximal incompatible subfamily.
The conclusion is predensity in that set; no cardinal chain condition is used. -/
theorem maximal_antichain (D : Set P) :
    ∃ A : Set P, A ⊆ D ∧
      (∀ p ∈ A, ∀ q ∈ A, ∀ r, r ≤ p → r ≤ q → p = q) ∧
      ∀ d ∈ D, ∃ a ∈ A, ∃ r, r ≤ d ∧ r ≤ a := by
  classical
  let C : Set (Set P) := {A | A ⊆ D ∧
    ∀ p ∈ A, ∀ q ∈ A, ∀ r, r ≤ p → r ≤ q → p = q}
  obtain ⟨A,hA,hmax⟩ := zorn_subset C (by
    intro c hc hchain
    refine ⟨⋃₀ c,⟨?_,?_⟩,fun s hs => Set.subset_sUnion_of_mem hs⟩
    · rintro p ⟨B,hB,hpB⟩
      exact (hc hB).1 hpB
    · rintro p ⟨B,hB,hpB⟩ q ⟨C,hC,hqC⟩ r hrp hrq
      rcases hchain.total hB hC with hBC | hCB
      · exact (hc hC).2 p (hBC hpB) q hqC r hrp hrq
      · exact (hc hB).2 p hpB q (hCB hqC) r hrp hrq)
  refine ⟨A,hA.1,hA.2,?_⟩
  intro d hd
  by_contra hn
  have hdA : d ∉ A := by
    intro h
    exact hn ⟨d,h,d,le_rfl,le_rfl⟩
  have hi : insert d A ∈ C := by
    refine ⟨Set.insert_subset hd hA.1,?_⟩
    intro p hp q hq r hrp hrq
    rcases hp with rfl | hp <;> rcases hq with rfl | hq
    · rfl
    · exact False.elim (hn ⟨q,hq,r,hrp,hrq⟩)
    · exact False.elim (hn ⟨p,hp,r,hrq,hrp⟩)
    · exact hA.2 p hp q hq r hrp hrq
  exact hdA (hmax hi (Set.subset_insert _ _) (Set.mem_insert _ _))

end
end PartitionConsistency.ForcingQuotient


/-! ## Maximum -/

namespace PartitionConsistency.ProductForcing
universe u
open SetForcingNames SetForcingNames.SymmetricSystem DiagramForcing
noncomputable section
variable {M I κ K : Type u} [LeftCancelMonoid M] [DiagramOrder.IsConical M]
variable {μ : Cardinal.{u}} (hμ : Cardinal.aleph0 ≤ μ)

/-- The local maximum principle furnished by root probes. Unlike the ordinary
maximum principle, the conclusion has a specified literal supporting diagram,
chosen before the witness. The name is a mixture over a Cohen antichain. -/
theorem localized_maximum [Infinite M] [Infinite I] [Uncountable K]
    (hcard : Cardinal.mk M = μ) (hsize : Cardinal.mk M < Cardinal.mk I)
    (hmerger : HasFiniteMergers M) (e : M)
    (he : Cardinal.mk ((Set.range (fun x : M => e * x))ᶜ : Set M) = Cardinal.mk M)
    (hprobes : RootProbes e K)
    {n} (φ : Formula (n+1)) (v : Fin n → (system (M := M) (I := I) (κ := κ) hμ).Name)
    (p q : Diagram M I) (hq : q.sub e = p)
    (hv : ∀ π ∈ SupportFilter.Fix p.range, ∀ i, π • v i = v i)
    (d₀ : CohenForcing.Condition I κ) (hd₀ : d₀.support ⊆ q.range)
    (hf : (system hμ).Forces v ((d₀,p) : Poset M I κ) φ.ex) :
    ∃ ν : (system (M := M) (I := I) (κ := κ) hμ).Name,
      (∀ π ∈ SupportFilter.Fix q.range, π • ν = ν) ∧
      (system hμ).Forces (Fin.snoc v ν) ((d₀,q) : Poset M I κ) φ := by
  classical
  let S := system (M := M) (I := I) (κ := κ) hμ
  have : Nonempty (Diagram M I) := ⟨p⟩
  let D : Set (CohenForcing.Condition I κ) := {a | a ≤ d₀ ∧ a.support ⊆ q.range ∧
    ∃ ν : S.Name, (∀ π ∈ SupportFilter.Fix q.range, π • ν = ν) ∧
      S.Forces (Fin.snoc v ν) ((a,q) : Poset M I κ) φ}
  obtain ⟨A,hAD,hanti,hpred⟩ := ForcingQuotient.maximal_antichain D
  have hchoose : ∀ a : A, ∃ ν : S.Name,
      (∀ π ∈ SupportFilter.Fix q.range, π • ν = ν) ∧
      S.Forces (Fin.snoc v ν) ((a.val,q) : Poset M I κ) φ :=
    fun a => (hAD a.property).2.2
  choose f hfix hforce using hchoose
  let act : A → Poset M I κ := fun a => ((a.val,q) : Condition M I κ)
  let H := SupportFilter.Fix q.range
  have hH : H ∈ S.filter := ⟨q.range,by rw [Diagram.cardinal_range,hcard],le_rfl⟩
  have hact : ∀ π ∈ H, ∀ a, S.move π (act a) = act a := by
    intro π hπ a
    have hfixπ := (SupportFilter.mem_Fix _ _).mp hπ
    change S.move π ((a.val,q) : Poset M I κ) = ((a.val,q) : Poset M I κ)
    rw [move_coe]
    apply congrArg WithTop.some
    apply Prod.ext
    · exact CohenForcing.Condition.permute_eq_of_fixes_support π a.val
        (fun j hj => hfixπ j ((hAD a.property).2.1 hj))
    · exact Diagram.permute_eq_of_fixes_range π q hfixπ
  have hcoh : ∀ i j r, r ≤ act i → r ≤ act j → S.atomic.EqF r (f i) (f j) := by
    intro i j r hri hrj
    obtain ⟨r₀,hr₀⟩ := exists_condition_below r
    have hij : i = j := Subtype.ext (hanti _ i.property _ j.property r₀.1
      (WithTop.coe_le_coe.mp (hr₀.trans hri)).1
      (WithTop.coe_le_coe.mp (hr₀.trans hrj)).1)
    subst j
    exact S.atomic.eq_refl _ _
  let ν := S.mix f act H hH (fun π hπ a => hfix a π hπ) hact
  refine ⟨ν,S.mix_fixed f act H hH _ hact,?_⟩
  apply S.atomic.forceFormula_of_dense S.atomic_regular
  intro t ht
  obtain ⟨t₀,ht₀⟩ := exists_condition_below t
  have htd : t₀.1 ≤ d₀ := (WithTop.coe_le_coe.mp (ht₀.trans ht)).1
  have htq : t₀.2 ≤ q := (WithTop.coe_le_coe.mp (ht₀.trans ht)).2
  let c := t₀.1.restrict q.range
  have hcd : c ≤ d₀ := by
    intro z hz
    exact ⟨htd hz,hd₀ ((CohenForcing.Condition.mem_support _ _).mpr ⟨z.1.2,z.2,hz⟩)⟩
  obtain ⟨d,hdc,hds,νd,hfixd,hforced⟩ := localized_existential hμ hcard hsize hmerger e he hprobes
    φ v p q hq hv d₀ hf c hcd (t₀.1.support_restrict_subset _)
  have hdD : d ∈ D := ⟨hdc.trans hcd,hds,νd,hfixd,hforced⟩
  obtain ⟨a,ha,b,hbd,hba⟩ := hpred d hdD
  let b' := b.restrict q.range
  have hbc : b' ≤ c := by
    intro z hz
    exact ⟨hbd (hdc hz),hz.2⟩
  have hba' : b' ≤ a := by
    intro z hz
    exact ⟨hba hz,(hAD ha).2.1 ((CohenForcing.Condition.mem_support _ _).mpr ⟨z.1.2,z.2,hz⟩)⟩
  have htcomp : CohenForcing.Condition.Compatible t₀.1 b' := by
    intro z x y hx hy
    exact b'.functional z x y (hbc ⟨hx,hy.2⟩) hy
  obtain ⟨s,hst,hsb⟩ := CohenForcing.Condition.compatible_iff.mp htcomp
  let a' : A := ⟨a,ha⟩
  have hsa : ((s,t₀.2) : Poset M I κ) ≤ act a' :=
    WithTop.coe_le_coe.mpr ⟨hsb.trans hba',htq⟩
  have heq := S.atomic.eq_mono hsa (S.eq_mix_at f act H hH (fun π hπ a => hfix a π hπ) hact hcoh a')
  refine ⟨((s,t₀.2) : Poset M I κ),
    (WithTop.coe_le_coe.mpr (show (s,t₀.2) ≤ t₀ from ⟨hst,le_rfl⟩)).trans ht₀,?_⟩
  exact (S.forces_snoc_congr φ v heq).mpr (S.atomic.forceFormula_mono hsa (hforce a'))

end
end PartitionConsistency.ProductForcing


/-! ## ChoiceFamily -/

namespace PartitionConsistency.SetLanguage

/-- Auxiliary formula for a value selected from the set `F(i)`.
Its variables are the family graph, the index, and the selected value. -/
def familyMember : Formula 3 :=
  .ex ((edge 0 1 3).conj (.mem 2 3))

end PartitionConsistency.SetLanguage

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

theorem forces_nonemptyFamily {n} (v : Fin n → S.Name) (p : P) (F d : Fin n) :
    S.Forces v p (SetLanguage.nonemptyFamily F d) ↔
      S.Forces ![v F,v d] p (SetLanguage.functionOn 0 1) ∧
      ∀ x y : S.Name, ∀ q, q ≤ p → S.atomic.MemF q x (v d) →
        ∀ r, r ≤ q → S.App r (v F) x y →
          ∀ s, s ≤ r → ∃ t, t ≤ s ∧ ∃ z : S.Name, S.atomic.MemF t z y := by
  simp only [Forces,SetLanguage.nonemptyFamily,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_mem,
    S.forces_edge,S.forces_nonempty]
  have hv : v ∘ ![F,d] = ![v F,v d] := by
    ext i
    fin_cases i <;> rfl
  simp [hv,Fin.snoc]

theorem forces_choiceForFamily {n} (v : Fin n → S.Name) (p : P) (c d F : Fin n) :
    S.Forces v p (SetLanguage.choiceForFamily c d F) ↔
      S.Forces ![v c,v d] p (SetLanguage.functionOn 0 1) ∧
      ∀ x y : S.Name, ∀ q, q ≤ p → S.atomic.MemF q x (v d) →
        ∀ r, r ≤ q → S.App r (v F) x y →
          ∀ s, s ≤ r → ∃ t, t ≤ s ∧ ∃ z : S.Name,
            S.App t (v c) x z ∧ S.atomic.MemF t z y := by
  simp only [Forces,SetLanguage.choiceForFamily,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_mem,
    ForcingQuotient.AtomicData.forceFormula_ex,S.forces_edge]
  have hv : v ∘ ![c,d,F] = ![v c,v d,v F] := by
    ext i
    fin_cases i <;> rfl
  have hfun : S.atomic.ForceFormula ![v c,v d,v F] p (SetLanguage.functionOn 0 1) ↔
      S.atomic.ForceFormula ![v c,v d] p (SetLanguage.functionOn 0 1) := by
    simp only [SetLanguage.functionOn,S.atomic.forceFormula_rename S.atomic_regular]
    have hc : ![v c,v d,v F] ∘ ![0,1] = ![v c,v d] ∘ ![0,1] := by
      ext i
      fin_cases i <;> rfl
    rw [hc]
  simpa [hv,Fin.snoc,Fin.castPred,Fin.castLT] using
    and_congr hfun (Iff.rfl :
      (∀ x y : S.Name, ∀ q, q ≤ p → S.atomic.MemF q x (v d) →
        ∀ r, r ≤ q → S.App r (v F) x y →
          ∀ s, s ≤ r → ∃ t, t ≤ s ∧ ∃ z : S.Name,
            S.App t (v c) x z ∧ S.atomic.MemF t z y) ↔ _)

theorem forces_familyMember (F x z : S.Name) (p : P) :
    S.Forces ![F,x,z] p SetLanguage.familyMember ↔
      ∀ q, q ≤ p → ∃ r, r ≤ q ∧ ∃ y : S.Name,
        S.App r F x y ∧ S.atomic.MemF r z y := by
  simp only [Forces,SetLanguage.familyMember,ForcingQuotient.AtomicData.forceFormula_ex,
    ForcingQuotient.AtomicData.forceFormula_conj,ForcingQuotient.AtomicData.forceFormula_mem,
    S.forces_edge]
  rfl

/-- A member of the domain of a forced nonempty family has a possible
choice value. Both the family's set value and the member are internal names. -/
theorem nonemptyFamily_member {n} (v : Fin n → S.Name) (p : P) (F d : Fin n)
    (hf : S.Forces v p (SetLanguage.nonemptyFamily F d)) (x : S.Name)
    (hx : S.atomic.MemF p x (v d)) :
    S.Forces ![v F,x] p SetLanguage.familyMember.ex := by
  obtain ⟨hfun,hne⟩ := (S.forces_nonemptyFamily v p F d).mp hf
  intro q hqp
  obtain ⟨r,hrq,y,ha,_⟩ := S.functionOn_total ![v F,v d] p 0 1 hfun x le_rfl hx q hqp
  obtain ⟨s,hsr,z,hz⟩ := hne x y p le_rfl hx r (hrq.trans hqp) ha r le_rfl
  refine ⟨s,hsr.trans hrq,z,?_⟩
  have hvec : Fin.snoc ![v F,x] z = ![v F,x,z] := by
    ext i
    fin_cases i <;> rfl
  rw [hvec]
  exact (S.forces_familyMember _ _ _ _).mpr (fun t hts =>
    ⟨t,le_rfl,y,S.app_mono (hts.trans hsr) ha,S.atomic.mem_mono hts hz⟩)

/-- Once the family's value at an index is specified, a selected member
belongs to that value. This uses single-valuedness of the actual graph. -/
theorem familyMember_mem {n} (v : Fin n → S.Name) (p : P) (F d : Fin n)
    (hfun : S.Forces v p (SetLanguage.functionOn F d)) (x y z : S.Name)
    (hx : S.atomic.MemF p x (v d)) (ha : S.App p (v F) x y)
    (hz : S.Forces ![v F,x,z] p SetLanguage.familyMember) : S.atomic.MemF p z y := by
  apply S.atomic_regular.2
  intro q hqp
  obtain ⟨r,hrq,t,hat,hzt⟩ := (S.forces_familyMember _ _ _ _).mp hz q hqp
  have he := S.functionOn_unique v r F d (S.atomic.forceFormula_mono (hrq.trans hqp) hfun)
    x t y (S.atomic.mem_mono (hrq.trans hqp) hx) hat (S.app_mono (hrq.trans hqp) ha)
  exact ⟨r,hrq,(S.atomic.mem_congr (S.atomic.eq_refl r z) he).mp hzt⟩

/-- The ordinary first-order ACwo sentence follows from dense internal
choice graphs. This is only a logical unpacking, with the ordinal and all
family hypotheses unchanged. -/
theorem forces_ACwo_of_dense
    (h : ∀ (p : P) (η F : S.Name),
      S.Forces ![η] p (SetLanguage.ordinal 0) →
      S.Forces ![F,η] p (SetLanguage.nonemptyFamily 0 1) →
      ∃ q, q ≤ p ∧ ∃ c : S.Name,
        S.Forces ![c,η,F] q (SetLanguage.choiceForFamily 0 1 2)) (p : P) :
    S.Forces Fin.elim0 p SetLanguage.ACwo := by
  change S.atomic.ForceFormula Fin.elim0 p SetLanguage.ACwo
  rw [SetLanguage.ACwo,S.atomic.forceFormula_all S.atomic_regular]
  intro η
  have hη : Fin.snoc (Fin.elim0 : Fin 0 → S.Name) η = ![η] := by
    ext i
    fin_cases i
    rfl
  rw [hη]
  rw [S.atomic.forceFormula_imp S.atomic_regular]
  intro q hqp ho
  rw [S.atomic.forceFormula_all S.atomic_regular]
  intro F
  have hF : Fin.snoc ![η] F = ![η,F] := by
    ext i
    fin_cases i <;> rfl
  rw [hF]
  rw [S.atomic.forceFormula_imp S.atomic_regular]
  intro r hrq hf
  have hf' : S.Forces ![F,η] r (SetLanguage.nonemptyFamily 0 1) :=
    (S.forces_nonemptyFamily ![F,η] r 0 1).mpr
      ((S.forces_nonemptyFamily ![η,F] r 1 0).mp hf)
  intro s hsr
  obtain ⟨t,hts,c,hc⟩ := h s η F (S.atomic.forceFormula_mono (hsr.trans hrq) ho)
    (S.atomic.forceFormula_mono hsr hf')
  refine ⟨t,hts,c,?_⟩
  have hcvec : Fin.snoc ![η,F] c = ![η,F,c] := by
    ext i
    fin_cases i <;> rfl
  rw [hcvec]
  exact (S.forces_choiceForFamily ![η,F,c] t 2 0 1).mpr
    ((S.forces_choiceForFamily ![c,η,F] t 0 1 2).mp hc)

end
end PartitionConsistency.SetForcingNames.SymmetricSystem

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 Γ)

/-- Uniformly supported local choices yield an actual internal set function,
not an external function substituted for the conclusion of ACwo. -/
theorem indexedGraph_choiceForFamily (X : ZFSet.{u}) (F : S.Name)
    (f : X → S.Name) (H : Subgroup Γ) (hH : H ∈ S.filter)
    (hfix : ∀ g ∈ H, ∀ i, g • f i = f i) (p : P)
    (hfun : S.Forces ![F,Name.check X] p (SetLanguage.functionOn 0 1))
    (hf : ∀ i : X, S.Forces ![F,Name.check i.val,f i] p SetLanguage.familyMember) :
    S.Forces ![S.indexedGraph X f H hH hfix,Name.check X,F] p
      (SetLanguage.choiceForFamily 0 1 2) := by
  apply (S.forces_choiceForFamily _ _ _ _ _).mpr
  refine ⟨S.indexedGraph_functionOn X f H hH hfix p,?_⟩
  intro x y q hqp hx r hrq ha s hsr
  obtain ⟨t,hts,i,hi,heq⟩ := (S.mem_check X x q).mp hx s (hsr.trans hrq)
  let j : X := ⟨i,hi⟩
  have hap : S.App t F (Name.check i) y :=
    (S.app_congr (S.atomic.eq_refl t F) heq (S.atomic.eq_refl t y)).mp
      (S.app_mono (hts.trans hsr) ha)
  have hm := S.familyMember_mem ![F,Name.check X] t 0 1
    (S.atomic.forceFormula_mono (hts.trans (hsr.trans (hrq.trans hqp))) hfun)
    (Name.check i) y (f j) (S.check_mem_of_mem hi t) hap
    (S.atomic.forceFormula_mono (hts.trans (hsr.trans (hrq.trans hqp))) (hf j))
  refine ⟨t,hts,f j,?_,hm⟩
  exact (S.app_congr (S.atomic.eq_refl t _) heq (S.atomic.eq_refl t _)).mpr
    (S.indexedGraph_app_at X f H hH hfix j t)

end
end PartitionConsistency.SetForcingNames.SymmetricSystem


/-! ## ACwo -/

namespace PartitionConsistency.ProductForcing
universe u
open SetForcingNames SetForcingNames.SymmetricSystem DiagramForcing
noncomputable section
variable {M I κ K : Type u} [LeftCancelMonoid M] [DiagramOrder.IsConical M]
variable {μ : Cardinal.{u}} (hμ : Cardinal.aleph0 ≤ μ)

/-- One previously chosen extension of the supporting diagram supports all
choices from a ground-indexed family, at arbitrary name ranks. The result is
an internal graph; the uniform maximum principle only constructs its name. -/
theorem ground_family_choice [Infinite M] [Infinite I] [Uncountable K]
    (hcard : Cardinal.mk M = μ) (hsize : Cardinal.mk M < Cardinal.mk I)
    (hmerger : HasFiniteMergers M) (e : M)
    (he : Cardinal.mk ((Set.range (fun x : M => e * x))ᶜ : Set M) = Cardinal.mk M)
    (hprobes : RootProbes e K) (X : ZFSet.{u})
    (F : (system (M := M) (I := I) (κ := κ) hμ).Name)
    (p q : Diagram M I) (hq : q.sub e = p)
    (hF : ∀ π ∈ SupportFilter.Fix p.range, π • F = F)
    (d₀ : CohenForcing.Condition I κ) (hd₀ : d₀.support ⊆ q.range)
    (hf : (system hμ).Forces ![F,Name.check X] ((d₀,p) : Poset M I κ)
      (SetLanguage.nonemptyFamily 0 1)) :
    ∃ c : (system (M := M) (I := I) (κ := κ) hμ).Name,
      (system hμ).Forces ![c,Name.check X,F] ((d₀,q) : Poset M I κ)
        (SetLanguage.choiceForFamily 0 1 2) := by
  let S := system (M := M) (I := I) (κ := κ) hμ
  have hw (i : X) : ∃ ν : S.Name,
      (∀ π ∈ SupportFilter.Fix q.range, π • ν = ν) ∧
      S.Forces ![F,Name.check i.val,ν] ((d₀,q) : Poset M I κ) SetLanguage.familyMember := by
    have hv : ∀ π ∈ SupportFilter.Fix p.range, ∀ j : Fin 2,
        π • (![F,Name.check i.val] : Fin 2 → S.Name) j = ![F,Name.check i.val] j := by
      intro π hπ j
      fin_cases j
      · exact hF π hπ
      · exact Name.smul_check S π _
    have hm := S.nonemptyFamily_member ![F,Name.check X] ((d₀,p) : Poset M I κ) 0 1 hf
      (Name.check i.val) (S.check_mem_of_mem i.property _)
    obtain ⟨ν,hν,hforce⟩ := localized_maximum hμ hcard hsize hmerger e he hprobes
      SetLanguage.familyMember ![F,Name.check i.val] p q hq hv d₀ hd₀ hm
    refine ⟨ν,hν,?_⟩
    have hvec : Fin.snoc ![F,Name.check i.val] ν = ![F,Name.check i.val,ν] := by
      ext j
      fin_cases j <;> rfl
    rwa [hvec] at hforce
  choose f hfix hforce using hw
  let H := SupportFilter.Fix q.range
  have hH : H ∈ S.filter := ⟨q.range,by rw [Diagram.cardinal_range,hcard],le_rfl⟩
  have hf' := (S.forces_nonemptyFamily ![F,Name.check X] ((d₀,p) : Poset M I κ) 0 1).mp hf
  exact ⟨S.indexedGraph X f H hH (fun π hπ i => hfix i π hπ),
    S.indexedGraph_choiceForFamily X F f H hH (fun π hπ i => hfix i π hπ) _
      (S.atomic.forceFormula_mono (p := ((d₀,p) : Poset M I κ)) (q := ((d₀,q) : Poset M I κ))
        (WithTop.coe_le_coe.mpr ⟨le_rfl,⟨e,hq⟩⟩) hf'.1) hforce⟩

/-- An arbitrary starting condition for a ground-indexed nonempty family
can be strengthened to force a choice graph. The family's support and the
Cohen condition are both put in the root before using probes. -/
theorem ground_family_choice_dense [Infinite M] [Infinite I] [Uncountable K]
    (hcard : Cardinal.mk M = μ) (hsize : Cardinal.mk M < Cardinal.mk I)
    (hmerger : HasFiniteMergers M) (e : M)
    (he : Cardinal.mk ((Set.range (fun x : M => e * x))ᶜ : Set M) = Cardinal.mk M)
    (hprobes : RootProbes e K) (X : ZFSet.{u})
    (F : (system (M := M) (I := I) (κ := κ) hμ).Name) (t : Poset M I κ)
    (hf : (system hμ).Forces ![F,Name.check X] t (SetLanguage.nonemptyFamily 0 1)) :
    ∃ s, s ≤ t ∧ ∃ c : (system (M := M) (I := I) (κ := κ) hμ).Name,
      (system hμ).Forces ![c,Name.check X,F] s (SetLanguage.choiceForFamily 0 1 2) := by
  let S := system (M := M) (I := I) (κ := κ) hμ
  obtain ⟨emb⟩ := (Cardinal.le_def M I).mp hsize.le
  let : Nonempty (Diagram M I) := ⟨⟨emb⟩⟩
  obtain ⟨d,hdt⟩ := exists_condition_below t
  obtain ⟨J,hJ,hfix⟩ := name_support hμ F
  have hU : Cardinal.mk ↥(J ∪ d.1.support) ≤ Cardinal.mk M := by
    rw [hcard]
    exact (Cardinal.mk_union_le _ _).trans
      ((add_le_add hJ (d.1.cardinal_support.trans hμ)).trans_eq (Cardinal.add_eq_self hμ))
  obtain ⟨p,hp,hcover⟩ := Diagram.extend_through hsize e he d.2 hU
  have hpd : ((d.1,p) : Poset M I κ) ≤ t :=
    (WithTop.coe_le_coe.mpr (show (d.1,p) ≤ d from ⟨le_rfl,⟨e,hp⟩⟩)).trans hdt
  obtain ⟨q,hq,_⟩ := Diagram.extend_through hsize e he p (J := ∅) (by simp)
  have hqp : q ≤ p := ⟨e,hq⟩
  obtain ⟨c,hc⟩ := ground_family_choice hμ hcard hsize hmerger e he hprobes X F p q hq
    (fun π hπ => hfix π ((SupportFilter.mem_Fix _ _).mpr
      (fun j hj => (SupportFilter.mem_Fix _ _).mp hπ j (hcover (Or.inl hj)))))
    d.1 (fun j hj => Diagram.range_antitone hqp (hcover (Or.inr hj)))
    (S.atomic.forceFormula_mono hpd hf)
  exact ⟨(d.1,q),(WithTop.coe_le_coe.mpr (show (d.1,q) ≤ (d.1,p) from ⟨le_rfl,hqp⟩)).trans hpd,c,hc⟩

/-- Choice for every internal ordinal-indexed family, without a rank cutoff.
Ordinal preservation first decides the index set to a ground ordinal, after
which one uniformly supported internal choice graph is constructed. -/
theorem forces_ACwo [Infinite M] [Infinite I] [Uncountable K]
    (hcard : Cardinal.mk M = μ) (hsize : Cardinal.mk M < Cardinal.mk I)
    (hmerger : HasFiniteMergers M) (e : M)
    (he : Cardinal.mk ((Set.range (fun x : M => e * x))ᶜ : Set M) = Cardinal.mk M)
    (hprobes : RootProbes e K) (p : Poset M I κ) :
    (system (M := M) (I := I) (κ := κ) hμ).Forces Fin.elim0 p SetLanguage.ACwo := by
  let S := system (M := M) (I := I) (κ := κ) hμ
  apply S.forces_ACwo_of_dense
  intro s η F ho hf'
  obtain ⟨t,hts,β,hη⟩ := S.forces_ordinal_decide ![η] s 0 ho s le_rfl
  have hf' := S.atomic.forceFormula_mono hts hf'
  have hchange : S.Forces ![F,Name.check β.toZFSet] t (SetLanguage.nonemptyFamily 0 1) := by
    apply (S.atomic.forceFormula_tuple_congr (p := t) (φ := SetLanguage.nonemptyFamily 0 1)
      (v := ![F,η]) (w := ![F,Name.check β.toZFSet]) ?_).mp hf'
    intro i
    fin_cases i
    · exact S.atomic.eq_refl t F
    · exact hη
  obtain ⟨a,hat,c,hc⟩ := ground_family_choice_dense hμ hcard hsize hmerger e he hprobes
    β.toZFSet F t hchange
  have hc' : S.Forces ![c,η,F] a (SetLanguage.choiceForFamily 0 1 2) := by
    apply (S.atomic.forceFormula_tuple_congr (p := a) (φ := SetLanguage.choiceForFamily 0 1 2)
      (v := ![c,Name.check β.toZFSet,F]) (w := ![c,η,F]) ?_).mp hc
    intro i
    fin_cases i
    · exact S.atomic.eq_refl a c
    · exact S.atomic.eq_symm (S.atomic.eq_mono hat hη)
    · exact S.atomic.eq_refl a F
  exact ⟨a,hat.trans hts,c,hc'⟩

end
end PartitionConsistency.ProductForcing

namespace PartitionConsistency.ConcreteSystem
open MonoidConstruction CardinalParameters DiagramForcing SetForcingNames
noncomputable section

instance : Uncountable K := Cardinal.aleph0_lt_mk_iff.mp
  (by rw [cardinal_K]; exact Cardinal.aleph0_lt_aleph_one.trans_le aleph_one_le_μ)

/-- The probes used by ordinal choice are actually present in the saturated
monoid. This is an instance of the executed requests with `a=1`. -/
theorem rootProbes : ProductForcing.RootProbes T.e K := by
  intro b hb
  let d : ProbeData T :=
    ⟨1,b,hb,⟨fun _ => 1,rfl,fun _ => dvd_refl _,fun _ => dvd_refl _⟩⟩
  obtain ⟨m,_,hm,hi⟩ := Saturation.probes Base.object K d
  refine ⟨m,fun i => (hm i).exit.trans (one_mul _),?_⟩
  intro i j hij z
  have hh := hi i j hij z
  change m i ∣ z ∧ m j ∣ z ↔ (1 : T) * T.e ∣ z at hh
  simpa only [one_mul] using! hh

/-- No additional cardinal or support principle is assumed here. -/
theorem forces_ACwo (p : P) : S.Forces Fin.elim0 p SetLanguage.ACwo :=
  ProductForcing.forces_ACwo aleph0_le_μ cardinal_T size_lt finiteMergers T.e
    complement_cardinal rootProbes p

/-- Consistency of the ZF + ACwo + ¬AC subtheory. The full target with
PP is proved below in `consistent_target`. -/
theorem consistent_ZF_ACwo_not_AC :
    Consistent (SetLanguage.ZF ∪ {SetLanguage.ACwo,SetLanguage.AC.neg}) := by
  apply S.consistent_of_forces (⊤ : P)
  intro φ hφ
  rcases hφ with hφ | hφ
  · exact forces_ZF ⊤ φ hφ
  · rcases hφ with rfl | rfl | hfalse
    · exact forces_ACwo ⊤
    · exact forces_not_AC ⊤

end
end PartitionConsistency.ConcreteSystem

end OAI