import Mathlib
import OAI.SetTheory.PartitionConsistency.Models.OrdinalPresentation

namespace OAI

/-! ## LocalList -/

namespace PartitionConsistency.SetLanguage

/-- A set is wellorderable exactly when it embeds in some ordinal. Both
quantified witnesses are internal sets; the injection is an internal graph. -/
def wellorderableFormula : Formula 1 :=
  .ex ((ordinal 1).conj (.ex (injection 2 0 1)))

def wellorderable {n} (a : Fin n) : Formula n :=
  Formula.rename ![a] wellorderableFormula

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_wellorderable {n} (v : Fin n → S.Name) (p : P) (a : Fin n) :
    S.Forces v p (SetLanguage.wellorderable a) ↔
      ∀ q, q ≤ p → ∃ r, r ≤ q ∧ ∃ η : S.Name,
        S.Forces ![η] r (SetLanguage.ordinal 0) ∧
        (∀ s, s ≤ r → ∃ t, t ≤ s ∧ ∃ J : S.Name,
          S.Forces ![J,v a,η] t (SetLanguage.injection 0 1 2)) := by
  simp only [Forces,SetLanguage.wellorderable,SetLanguage.wellorderableFormula,
    S.atomic.forceFormula_rename S.atomic_regular,
    ForcingQuotient.AtomicData.forceFormula_ex,ForcingQuotient.AtomicData.forceFormula_conj]
  have hordinal (η : S.Name) (r : P) :
      S.Forces (Fin.snoc (v ∘ ![a]) η) r (SetLanguage.ordinal 1) ↔
      S.Forces ![η] r (SetLanguage.ordinal 0) := by
    simp only [Forces,SetLanguage.ordinal,SetLanguage.transitiveSet,
      SetLanguage.membershipLinear,SetLanguage.membershipWellFounded,
      S.atomic.forceFormula_rename S.atomic_regular,
      ForcingQuotient.AtomicData.forceFormula_conj]
    have hv : (Fin.snoc (v ∘ ![a]) η) ∘ ![1] = ![η] ∘ ![0] := by
      funext i
      fin_cases i
      rfl
    rw [hv]
  have hinjection (η J : S.Name) (t : P) :
      S.Forces (Fin.snoc (Fin.snoc (v ∘ ![a]) η) J) t (SetLanguage.injection 2 0 1) ↔
      S.Forces ![J,v a,η] t (SetLanguage.injection 0 1 2) := by
    simp only [Forces,SetLanguage.injection,S.atomic.forceFormula_rename S.atomic_regular]
    have hv : (Fin.snoc (Fin.snoc (v ∘ ![a]) η) J) ∘ ![2,0,1] =
        ![J,v a,η] ∘ ![0,1,2] := by
      funext i
      fin_cases i <;> rfl
    rw [hv]
  simpa only [Forces] using (show (∀ q, q ≤ p → ∃ r, r ≤ q ∧ ∃ η : S.Name,
      S.Forces (Fin.snoc (v ∘ ![a]) η) r (SetLanguage.ordinal 1) ∧
      (∀ s, s ≤ r → ∃ t, t ≤ s ∧ ∃ J : S.Name,
        S.Forces (Fin.snoc (Fin.snoc (v ∘ ![a]) η) J) t (SetLanguage.injection 2 0 1))) ↔ _ from by
    simp only [hordinal,hinjection])

/-- Injecting a set into a checked ordinal is enough for the genuine
wellorderability formula. No ordinal preservation assumption is used. -/
theorem wellorderable_of_check_injection (Y J : S.Name) (α : Ordinal.{u}) (p : P)
    (h : S.Forces ![J,Y,Name.check α.toZFSet] p (SetLanguage.injection 0 1 2)) :
    S.Forces ![Y] p (SetLanguage.wellorderable 0) := by
  rw [S.forces_wellorderable]
  intro q hqp
  exact ⟨q,le_rfl,Name.check α.toZFSet,S.forces_checkOrdinal α q,
    fun r hrq => ⟨r,le_rfl,J,S.atomic.forceFormula_mono (hrq.trans hqp) h⟩⟩

theorem no_check_injection_of_not_wellorderable (Y : S.Name) (p : P)
    (h : S.Forces ![Y] p (SetLanguage.wellorderable 0).neg) (α : Ordinal.{u}) :
    ∀ q, q ≤ p → ∀ J : S.Name,
      ¬ S.Forces ![J,Y,Name.check α.toZFSet] q (SetLanguage.injection 0 1 2) := by
  intro q hqp J hj
  exact (S.atomic.forceFormula_neg S.atomic_regular _ _ _).mp h q hqp
    (S.wellorderable_of_check_injection Y J α q hj)

end
end PartitionConsistency.SetForcingNames.SymmetricSystem

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

/-- The range of all canonical E-classes of labels. For an equivalence
relation this is A/E, with the actual classes as its members. -/
def quotientName (E : (system (M := M) (I := I) (κ := κ) hμ).Name) :
    (system (M := M) (I := I) (κ := κ) hμ).Name :=
  (system hμ).collect (labelClass hμ c E) (fun _ _ => True)
    ((system hμ).tupleStabilizer ![E]) ((system hμ).tupleStabilizer_mem ![E]) (by
      intro π hπ j p hp
      refine ⟨π j,?_,trivial⟩
      have he : π • E = E := ((system hμ).mem_tupleStabilizer ![E] π).mp hπ 0
      rw [labelClass_move,he])

theorem mem_quotientName (E y : (system (M := M) (I := I) (κ := κ) hμ).Name)
    (p : Poset M I κ) :
    (system hμ).atomic.MemF p y (quotientName hμ c E) ↔
      ∀ q, q ≤ p → ∃ r, r ≤ q ∧ ∃ j : I,
        (system hμ).atomic.EqF r y (labelClass hμ c E j) := by
  rw [quotientName,(system hμ).mem_collect]
  constructor
  · intro h q hqp
    obtain ⟨r,hrq,j,_,_,_,he⟩ := h q hqp
    exact ⟨r,hrq,j,he⟩
  · intro h q hqp
    obtain ⟨r,hrq,j,he⟩ := h q hqp
    exact ⟨r,hrq,j,r,trivial,le_rfl,he⟩

/-- Membership is exactly the first-order class predicate, not a quotient
surrogate supplied with the desired comparison property. -/
theorem mem_quotientName_iff_isClass
    (E y : (system (M := M) (I := I) (κ := κ) hμ).Name) (p : Poset M I κ) :
    (system hμ).atomic.MemF p y (quotientName hμ c E) ↔
      (system hμ).Forces ![y,labelSet hμ c,E] p (SetLanguage.isClass 0 1 2) := by
  let S := system (M := M) (I := I) (κ := κ) hμ
  rw [mem_quotientName,S.forces_isClass]
  constructor
  · intro h q hqp
    obtain ⟨r,hrq,j,he⟩ := h q hqp
    exact ⟨r,hrq,label hμ c j,label_mem_labelSet hμ c j r,he⟩
  · intro h q hqp
    obtain ⟨r,hrq,x,hx,he⟩ := h q hqp
    obtain ⟨s,hsr,j,hxj⟩ := (mem_labelSet hμ c x r).mp hx r le_rfl
    exact ⟨s,hsr.trans hrq,j,S.atomic.eq_trans (S.atomic.eq_mono hsr he)
      (S.relationClass_congr (S.atomic.eq_refl s _) (S.atomic.eq_refl s _) hxj)⟩

theorem quotientName_fixed (E : (system (M := M) (I := I) (κ := κ) hμ).Name)
    (π : Equiv.Perm I) (he : π • E = E) :
    π • quotientName hμ c E = quotientName hμ c E := by
  apply Subtype.ext
  refine (system hμ).collectName_fixed _ _ ((system hμ).tupleStabilizer ![E]) ?_ π ?_
  · intro σ hσ j p hp
    refine ⟨σ j,?_,trivial⟩
    have hs : σ • E = E := ((system hμ).mem_tupleStabilizer ![E] σ).mp hσ 0
    rw [labelClass_move,hs]
  · apply ((system hμ).mem_tupleStabilizer ![E] π).mpr
    intro j
    fin_cases j
    exact he

/-- A ground ordinal enumerating the entire normalized local-name set. -/
def localListOrdinal (r : Diagram M I) : Ordinal.{u} :=
  (exists_ordinal_equiv (LocalName hμ c r)).choose

def localListEquiv (r : Diagram M I) :
    (localListOrdinal hμ c r).toZFSet ≃ LocalName hμ c r :=
  (exists_ordinal_equiv (LocalName hμ c r)).choose_spec.some

def localListEntry (r : Diagram M I) (i : (localListOrdinal hμ c r).toZFSet) :
    (system (M := M) (I := I) (κ := κ) hμ).Name := (localListEquiv hμ c r i).name

theorem localListEntry_fixed (r : Diagram M I) (π : Equiv.Perm I)
    (hπ : π ∈ SupportFilter.Fix r.range) (i : (localListOrdinal hμ c r).toZFSet) :
    π • localListEntry hμ c r i = localListEntry hμ c r i :=
  (localListEquiv hμ c r i).fixed π hπ

theorem localList_support (hcard : Cardinal.mk M ≤ μ) (r : Diagram M I) :
    SupportFilter.Fix r.range ∈ (system (M := M) (I := I) (κ := κ) hμ).filter :=
  ⟨r.range,(Diagram.cardinal_range r).trans_le hcard,le_rfl⟩

/-- The canonical evaluation list range, formed as a genuine HS name
with support D_r; its domain has been enumerated by a ground ordinal. -/
def localList (hcard : Cardinal.mk M ≤ μ) (r : Diagram M I) :
    (system (M := M) (I := I) (κ := κ) hμ).Name :=
  (system (M := M) (I := I) (κ := κ) hμ).uniformRange
    (ι := (localListOrdinal hμ c r).toZFSet) (localListEntry hμ c r)
    (SupportFilter.Fix r.range)
    (localList_support (κ := κ) hμ hcard r)
    (by
      intro π hπ i
      exact localListEntry_fixed hμ c r π hπ i)

theorem localList_fixed (hcard : Cardinal.mk M ≤ μ) (r : Diagram M I)
    (π : Equiv.Perm I) (hπ : π ∈ SupportFilter.Fix r.range) :
    π • localList hμ c hcard r = localList hμ c hcard r := by
  unfold localList
  exact (system (M := M) (I := I) (κ := κ) hμ).uniformRange_fixed (ι := (localListOrdinal hμ c r).toZFSet)
    (localListEntry hμ c r) (SupportFilter.Fix r.range)
    (localList_support (κ := κ) hμ hcard r) (localListEntry_fixed hμ c r) π hπ

theorem mem_localList (hcard : Cardinal.mk M ≤ μ) (r : Diagram M I)
    (y : (system (M := M) (I := I) (κ := κ) hμ).Name) (p : Poset M I κ) :
    (system hμ).atomic.MemF p y (localList hμ c hcard r) ↔
      ∀ q, q ≤ p → ∃ s, s ≤ q ∧ ∃ ν : LocalName hμ c r,
        (system hμ).atomic.EqF s y ν.name := by
  unfold localList
  rw [(system (M := M) (I := I) (κ := κ) hμ).mem_uniformRange]
  constructor
  · intro h q hqp
    obtain ⟨s,hsq,i,he⟩ := h q hqp
    exact ⟨s,hsq,localListEquiv hμ c r i,he⟩
  · intro h q hqp
    obtain ⟨s,hsq,ν,he⟩ := h q hqp
    obtain ⟨i,rfl⟩ := (localListEquiv hμ c r).surjective ν
    exact ⟨s,hsq,i,he⟩

theorem localName_mem_localList (hcard : Cardinal.mk M ≤ μ) (r : Diagram M I)
    (ν : LocalName hμ c r) (p : Poset M I κ) :
    (system hμ).atomic.MemF p ν.name (localList hμ c hcard r) :=
  (mem_localList hμ c hcard r ν.name p).mpr
    (fun q _ => ⟨q,le_rfl,ν,(system hμ).atomic.eq_refl q ν.name⟩)

/-- The list is wellorderable *inside* the symmetric interpretation,
via its least-occurrence injection into its checked index ordinal. -/
theorem localList_wellorderable (hcard : Cardinal.mk M ≤ μ) (r : Diagram M I)
    (p : Poset M I κ) :
    (system hμ).Forces ![localList hμ c hcard r] p (SetLanguage.wellorderable 0) :=
  (system (M := M) (I := I) (κ := κ) hμ).wellorderable_of_check_injection _ _
    (localListOrdinal hμ c r) p
    ((system (M := M) (I := I) (κ := κ) hμ).uniformRangeInverse_injection
      (localListOrdinal hμ c r).toZFSet (localListEntry hμ c r) (SupportFilter.Fix r.range)
      (localList_support (κ := κ) hμ hcard r) (localListEntry_fixed hμ c r) p)

/-- Nonwellorderability supplies densely an actual E-class outside every
value on the local evaluation list. Nonmembership persists below the chosen
condition; it is not just a failure to decide membership. -/
theorem outside_localList (hcard : Cardinal.mk M ≤ μ) (r : Diagram M I)
    (E : (system (M := M) (I := I) (κ := κ) hμ).Name)
    (hE : ∀ π ∈ SupportFilter.Fix r.range, π • E = E) (p : Poset M I κ)
    (hno : (system hμ).Forces ![quotientName hμ c E] p (SetLanguage.wellorderable 0).neg) :
    ∀ q, q ≤ p → ∃ s, s ≤ q ∧ ∃ y : (system hμ).Name,
      (system hμ).atomic.MemF s y (quotientName hμ c E) ∧
      ∀ t, t ≤ s → ¬ (system hμ).atomic.MemF t y (localList hμ c hcard r) := by
  apply (system (M := M) (I := I) (κ := κ) hμ).outside_uniformRange
    (localListOrdinal hμ c r).toZFSet (localListEntry hμ c r)
    (quotientName hμ c E) (SupportFilter.Fix r.range)
    (localList_support (κ := κ) hμ hcard r) (localListEntry_fixed hμ c r)
    (fun π hπ => quotientName_fixed hμ c E π (hE π hπ)) p
  exact (system (M := M) (I := I) (κ := κ) hμ).no_check_injection_of_not_wellorderable
    _ p hno (localListOrdinal hμ c r)

end
end PartitionConsistency.ProductForcing


/-! ## OutsideClass -/

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

/-- A class outside the *entire* local-name evaluation list, decided in a
literal stronger diagram that also contains all the condition coordinates.
The right factor of the root is recorded and is necessarily nontrivial. -/
def outsideClassSet (hcard : Cardinal.mk M ≤ μ) (p : Diagram M I)
    (E : (system (M := M) (I := I) (κ := κ) hμ).Name) :
    Set (CohenForcing.Condition I κ) :=
  {d | ∃ (t : Diagram M I) (b : M), t.sub b = p ∧ b ≠ 1 ∧
    d.support ⊆ t.range ∧ ∃ j ∈ t.range,
      ∀ s : Poset M I κ, s ≤ (d,t) →
        ¬ (system hμ).atomic.MemF s (labelClass hμ c E j) (localList hμ c hcard p)}

/-- This is a local dense-set theorem derived from nonwellorderability, not
an additional assumption that the unavailable class exists. -/
theorem outsideClassSet_denseBelow [Infinite M] [Infinite I]
    (hcard : Cardinal.mk M ≤ μ) (hsize : Cardinal.mk M < Cardinal.mk I) (e : M)
    (he : Cardinal.mk ((Set.range (fun x : M => e*x))ᶜ : Set M) = Cardinal.mk M)
    (p : Diagram M I) (E : (system (M := M) (I := I) (κ := κ) hμ).Name)
    (hE : ∀ π ∈ SupportFilter.Fix p.range, π • E = E)
    (d₀ : CohenForcing.Condition I κ)
    (hno : (system hμ).Forces ![quotientName hμ c E] ((d₀,p) : Poset M I κ)
      (SetLanguage.wellorderable 0).neg) :
    ∀ d, d ≤ d₀ → ∃ a, a ≤ d ∧ a ∈ outsideClassSet hμ c hcard p E := by
  intro d hdd
  let S := system (M := M) (I := I) (κ := κ) hμ
  obtain ⟨s,hs,y,hy,hout⟩ := outside_localList hμ c hcard p E hE _ hno
    ((d,p) : Poset M I κ) (WithTop.coe_le_coe.mpr ⟨hdd,le_rfl⟩)
  obtain ⟨u,hus,j,hyj⟩ := (mem_quotientName hμ c E y s).mp hy s le_rfl
  let : Nonempty (Diagram M I) := ⟨p⟩
  obtain ⟨a,hau⟩ := exists_condition_below u
  have hap := WithTop.coe_le_coe.mp ((hau.trans hus).trans hs)
  have hU : Cardinal.mk ↥(a.1.support ∪ {j}) ≤ Cardinal.mk M := by
    apply (Cardinal.mk_union_le _ _).trans
    have hω := Cardinal.aleph0_le_mk M
    apply (add_le_add (a.1.cardinal_support.trans hω) ?_).trans_eq (Cardinal.add_eq_self hω)
    simpa only [Cardinal.mk_singleton] using Cardinal.one_le_aleph0.trans hω
  obtain ⟨t,hta,hcover⟩ := Diagram.extend_through hsize e he a.2 hU
  have hta' : t ≤ a.2 := ⟨e,hta⟩
  have htu : ((a.1,t) : Poset M I κ) ≤ u :=
    (WithTop.coe_le_coe.mpr (show (a.1,t) ≤ a from ⟨le_rfl,hta'⟩)).trans hau
  have hts := htu.trans hus
  have hjt : j ∈ t.range := hcover (Or.inr (Set.mem_singleton j))
  have hnot : ∀ z : Poset M I κ, z ≤ (a.1,t) →
      ¬ S.atomic.MemF z (labelClass hμ c E j) (localList hμ c hcard p) := by
    intro z hzt hz
    apply hout z (hzt.trans hts)
    exact (S.atomic.mem_congr (S.atomic.eq_mono (hzt.trans htu) hyj)
      (S.atomic.eq_refl z _)).mpr hz
  obtain ⟨b,hb⟩ := hta'.trans hap.2
  have hbn : b ≠ 1 := by
    intro h
    have htp : t = p := by simpa only [h,Diagram.sub_one] using hb
    have hjp : j ∈ p.range := htp ▸ hjt
    exact hnot (a.1,t) le_rfl
      (localName_mem_localList hμ c hcard p (localLabelClass hμ c p E hE j hjp) (a.1,t))
  exact ⟨a.1,hap.1,t,b,hb,hbn,fun k hk => hcover (Or.inl hk),j,hjt,hnot⟩

/-- The standard incompatible padding gives a dense set in the whole Cohen
forcing. This is the precise requirement to be met by the intermediate
ordinary extension. -/
def outsideClassDenseSet (hcard : Cardinal.mk M ≤ μ) (p : Diagram M I)
    (E : (system (M := M) (I := I) (κ := κ) hμ).Name) (d₀ : CohenForcing.Condition I κ) :
    Set (CohenForcing.Condition I κ) :=
  {d | d ∈ outsideClassSet hμ c hcard p E ∨ ¬ Compatible d d₀}

theorem outsideClassDenseSet_dense [Infinite M] [Infinite I]
    (hcard : Cardinal.mk M ≤ μ) (hsize : Cardinal.mk M < Cardinal.mk I) (e : M)
    (he : Cardinal.mk ((Set.range (fun x : M => e*x))ᶜ : Set M) = Cardinal.mk M)
    (p : Diagram M I) (E : (system (M := M) (I := I) (κ := κ) hμ).Name)
    (hE : ∀ π ∈ SupportFilter.Fix p.range, π • E = E)
    (d₀ : CohenForcing.Condition I κ)
    (hno : (system hμ).Forces ![quotientName hμ c E] ((d₀,p) : Poset M I κ)
      (SetLanguage.wellorderable 0).neg) :
    Dense (outsideClassDenseSet hμ c hcard p E d₀) :=
  dense_local_or_incompatible d₀ _
    (outsideClassSet_denseBelow hμ c hcard hsize e he p E hE d₀ hno)

/-- An actual hit supplies the nontrivial witness used in the probe argument.
Only the explicitly identified dense set is mentioned here; this lemma does
not posit existence of an ambient filter meeting every ambient dense set. -/
theorem outsideClass_of_meets (hcard : Cardinal.mk M ≤ μ)
    (F : GenericFilter (CohenForcing.Condition I κ)) (p : Diagram M I)
    (E : (system (M := M) (I := I) (κ := κ) hμ).Name)
    (d₀ : CohenForcing.Condition I κ) (hd₀ : d₀ ∈ F)
    (hmeets : ∃ d, d ∈ F ∧ d ∈ outsideClassDenseSet hμ c hcard p E d₀) :
    ∃ d, d ∈ F ∧ d ∈ outsideClassSet hμ c hcard p E := by
  obtain ⟨d,hd,hm | hn⟩ := hmeets
  · exact ⟨d,hd,hm⟩
  · exact (hn (compatible_of_mem F hd hd₀)).elim

end
end PartitionConsistency.ProductForcing


/-! ## ClassFiber -/

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

/-- Persistent exclusion from the evaluation list of *all* local names at
p. This statement is expressed in the actual symmetric forcing relation. -/
def OutsideLocal (hcard : Cardinal.mk M ≤ μ) (p s : Diagram M I)
    (d : CohenForcing.Condition I κ) (σ : LocalName hμ c s) : Prop :=
  ∀ z : Poset M I κ, z ≤ (d,s) →
    ¬ (system hμ).atomic.MemF z σ.name (localList hμ c hcard p)

/-- A class outside the full evaluation list cannot be the inclusion of
any local quotient element at that root. Only membership of its witnessing
condition in the filter is used here. -/
theorem outsideLocal_not_image (hcard : Cardinal.mk M ≤ μ)
    (F : GenericFilter (CohenForcing.Condition I κ)) (p s : Diagram M I)
    (hsp : s ≤ p) (d : CohenForcing.Condition I κ) (hd : d ∈ F)
    (σ : LocalName hμ c s) (hout : OutsideLocal hμ c hcard p s d σ)
    (x : LocalQuotient (c := c) hμ F p) :
    LocalQuotient.restrict F hsp x ≠ LocalQuotient.ofName F σ := by
  induction x using Quotient.inductionOn with
  | h τ =>
    intro he
    obtain ⟨a,ha,heq⟩ := (LocalQuotient.ofName_eq F (τ.restrict hsp) σ).mp he
    obtain ⟨b,hb,hbd,hba⟩ := F.directed _ hd _ ha
    have hσ : (system hμ).atomic.EqF ((OrderDual.ofDual b,s) : Poset M I κ)
        σ.name τ.name := (system hμ).atomic.eq_symm
      ((system hμ).atomic.eq_mono
        (p := ((OrderDual.ofDual a,s) : Poset M I κ))
        (q := ((OrderDual.ofDual b,s) : Poset M I κ))
        (WithTop.coe_le_coe.mpr ⟨hba,le_rfl⟩) heq)
    apply hout (OrderDual.ofDual b,s) (WithTop.coe_le_coe.mpr ⟨hbd,le_rfl⟩)
    exact ((system hμ).atomic.mem_congr hσ ((system hμ).atomic.eq_refl _ _)).mpr
      (localName_mem_localList hμ c hcard p τ (OrderDual.ofDual b,s))

/-- Support descent over an exact intersection prevents an outside class
from equaling any element supported by the other diagram. -/
theorem outsideLocal_not_equal [Infinite M] [Infinite I]
    (hcard : Cardinal.mk M ≤ μ) (hsize : Cardinal.mk M < Cardinal.mk I)
    (hmerger : HasFiniteMergers M) (F : GenericFilter (CohenForcing.Condition I κ))
    (p s₀ s₁ v : Diagram M I) (hs₀ : s₀ ≤ p) (hs₁ : s₁ ≤ p)
    (hinter : s₀.range ∩ s₁.range = p.range) (hv₀ : v ≤ s₀) (hv₁ : v ≤ s₁)
    (d : CohenForcing.Condition I κ) (hd : d ∈ F) (σ : LocalName hμ c s₀)
    (hout : OutsideLocal hμ c hcard p s₀ d σ)
    (y : LocalQuotient (c := c) hμ F s₁) :
    LocalQuotient.restrict F hv₀ (LocalQuotient.ofName F σ) ≠
      LocalQuotient.restrict F hv₁ y := by
  intro he
  obtain ⟨x,hx,_⟩ := LocalQuotient.intersection F hcard hsize hmerger
    p s₀ s₁ v hs₀ hs₁ hinter hv₀ hv₁ (LocalQuotient.ofName F σ) y he
  exact outsideLocal_not_image hμ c hcard F p s₀ hs₀ d hd σ hout x hx

/-- A supported eligible class at any subdiagram gives a genuine element
of D_F(r), even when that subdiagram is not itself below q. -/
def classFromLocal [Infinite M] [Infinite I]
    (hcard : Cardinal.mk M ≤ μ) (hsize : Cardinal.mk M < Cardinal.mk I)
    (hmerger : HasFiniteMergers M) (F : GenericFilter (CohenForcing.Condition I κ))
    (q r s : Diagram M I) (hrq : r ≤ q) (hrs : r ≤ s)
    (E : (system (M := M) (I := I) (κ := κ) hμ).Name)
    (hE : ∀ π ∈ SupportFilter.Fix q.range, π • E = E)
    (σ : LocalName hμ c s) (hσ : EligibleName hμ c F s E σ) :
    (eligibleSystem hμ c hcard hsize hmerger F q E hE).Obj r :=
  ⟨LocalQuotient.restrict F hrs (LocalQuotient.ofName F σ),hrq,
    eligible_restrict hμ c F E hrs (LocalQuotient.ofName F σ) hσ⟩

/-- The exact profile for a class on one probe. The positive availability
comes from retaining the name on larger ranges; the negative test is the
actual support-descent contradiction, not a multiplicity assumption. -/
theorem classFromLocal_profile [Infinite M] [Infinite I]
    (hcard : Cardinal.mk M ≤ μ) (hsize : Cardinal.mk M < Cardinal.mk I)
    (hmerger : HasFiniteMergers M) (F : GenericFilter (CohenForcing.Condition I κ))
    (q r p : Diagram M I) (a e m b : M) (hqa : r.sub a = q)
    (hp : r.sub (a*e) = p) (hmb : m*b = a*e)
    (U : ConeIdeal (show LeftDivOrder M from a))
    (hm : ∀ n : M, n ∣ a ∧ n ∣ m ↔ n ∈ U.carrier)
    (hinter : ∀ n : M, n ∣ a → n ∉ U.carrier →
      ∀ z : M, n ∣ z ∧ m ∣ z ↔ a*e ∣ z)
    (E : (system (M := M) (I := I) (κ := κ) hμ).Name)
    (hE : ∀ π ∈ SupportFilter.Fix q.range, π • E = E)
    (σ : LocalName hμ c (r.sub m)) (hσ : EligibleName hμ c F (r.sub m) E σ)
    (d : CohenForcing.Condition I κ) (hd : d ∈ F)
    (hout : OutsideLocal hμ c hcard p (r.sub m) d σ) :
    (eligibleSystem hμ c hcard hsize hmerger F q E hE).availability r a
      (classFromLocal hμ c hcard hsize hmerger F q r (r.sub m)
        ⟨a,hqa⟩ (r.self_le_sub m) E hE σ hσ) = U := by
  let D := eligibleSystem hμ c hcard hsize hmerger F q E hE
  let x := classFromLocal hμ c hcard hsize hmerger F q r (r.sub m)
    ⟨a,hqa⟩ (r.self_le_sub m) E hE σ hσ
  have hmp : r.sub m ≤ p := ⟨b,by rw [Diagram.sub_sub,hmb,hp]⟩
  apply ConeIdeal.ext
  ext n
  change (n ≤ a ∧ D.Available r x n) ↔ n ∈ U.carrier
  constructor
  · rintro ⟨hna,y,hy⟩
    by_contra hnu
    have hnp : r.sub n ≤ p := by
      rw [← hp]
      exact r.sub_mono (hna.trans (LeftDivOrder.le_mul_right a e))
    have hi : (r.sub m).range ∩ (r.sub n).range = p.range := by
      rw [Set.inter_comm,← hp]
      exact r.range_inter_sub n m (a*e) (hinter n ((LeftDivOrder.le_iff_dvd _ _).mp hna) hnu)
    apply outsideLocal_not_equal hμ c hcard hsize hmerger F p (r.sub m) (r.sub n) r
      hmp hnp hi (r.self_le_sub _) (r.self_le_sub _) d hd σ hout y.val
    exact (congrArg Subtype.val hy).symm
  · intro hnu
    have hh := (hm n).mpr hnu
    have hna : n ≤ (a : LeftDivOrder M) := (LeftDivOrder.le_iff_dvd _ _).mpr hh.1
    have hnm : n ≤ (m : LeftDivOrder M) := (LeftDivOrder.le_iff_dvd _ _).mpr hh.2
    have hnq : r.sub n ≤ q := hqa ▸ r.sub_mono hna
    let y := classFromLocal hμ c hcard hsize hmerger F q (r.sub n) (r.sub m)
      hnq (r.sub_mono hnm) E hE σ hσ
    refine ⟨hna,y,?_⟩
    apply Subtype.ext
    exact LocalQuotient.restrict_restrict F (r.sub_mono hnm) (r.self_le_sub n)
      (LocalQuotient.ofName F σ)

/-- Distinct hit probes yield distinct symbolic classes, all in the exact
specified fiber. This map uses actual names, actual forcing eligibility,
and the proved intersection theorem. -/
def classFiberEmbedding [Infinite M] [Infinite I]
    (hcard : Cardinal.mk M ≤ μ) (hsize : Cardinal.mk M < Cardinal.mk I)
    (hmerger : HasFiniteMergers M) (F : GenericFilter (CohenForcing.Condition I κ))
    {q : Diagram M I} (w : Vertex q) (p : Diagram M I) (e b : M)
    (hp : w.diagram.sub (w.index*e) = p) {K : Type u} (m : K → M)
    (hmb : ∀ i, m i*b = w.index*e)
    (hm : ∀ i (n : M), n ∣ w.index ∧ n ∣ m i ↔ n ∈ w.ideal.carrier)
    (hinter : ∀ i (n : M), n ∣ w.index → n ∉ w.ideal.carrier →
      ∀ z : M, n ∣ z ∧ m i ∣ z ↔ w.index*e ∣ z)
    (hind : ∀ i j, i ≠ j → ∀ z : M, m i ∣ z ∧ m j ∣ z ↔ w.index*e ∣ z)
    (E : (system (M := M) (I := I) (κ := κ) hμ).Name)
    (hE : ∀ π ∈ SupportFilter.Fix q.range, π • E = E)
    (σ : ∀ i, LocalName hμ c (w.diagram.sub (m i)))
    (hσ : ∀ i, EligibleName hμ c F (w.diagram.sub (m i)) E (σ i))
    (d : K → CohenForcing.Condition I κ) (hd : ∀ i, d i ∈ F)
    (hout : ∀ i, OutsideLocal hμ c hcard p (w.diagram.sub (m i)) (d i) (σ i)) :
    K ↪ (eligibleSystem hμ c hcard hsize hmerger F q E hE).vertexFiber w where
  toFun i := ⟨classFromLocal hμ c hcard hsize hmerger F q w.diagram
    (w.diagram.sub (m i)) ⟨w.index,w.root⟩ (w.diagram.self_le_sub _) E hE (σ i) (hσ i),
    classFromLocal_profile hμ c hcard hsize hmerger F q w.diagram p w.index e (m i) b
      w.root hp (hmb i) w.ideal (hm i) (hinter i) E hE (σ i) (hσ i) (d i) (hd i) (hout i)⟩
  inj' := by
    intro i j he
    by_contra hij
    have hip (k : K) : w.diagram.sub (m k) ≤ p :=
      ⟨b,by rw [Diagram.sub_sub,hmb k,hp]⟩
    have hi : (w.diagram.sub (m i)).range ∩ (w.diagram.sub (m j)).range = p.range := by
      rw [← hp]
      exact w.diagram.range_inter_sub (m i) (m j) (w.index*e) (hind i j hij)
    exact outsideLocal_not_equal hμ c hcard hsize hmerger F p
      (w.diagram.sub (m i)) (w.diagram.sub (m j)) w.diagram (hip i) (hip j) hi
      (w.diagram.self_le_sub _) (w.diagram.self_le_sub _) (d i) (hd i)
      (σ i) (hout i) (LocalQuotient.ofName F (σ j))
      (congrArg (fun z => z.val.val) he)

/-- Transport the actual outside label-class witness to all copies of its
diagram over p. The names remain normalized names in the stated local sets,
and their exclusions are forced at the transported conditions. -/
theorem outsideClass_copies (hcard : Cardinal.mk M ≤ μ)
    (hsize : Cardinal.mk M < Cardinal.mk I) (p r : Diagram M I) (a e b : M)
    (hp : r.sub (a*e) = p) {K : Type u} (m : K → M) (hm : ∀ i, m i*b = a*e)
    (E : (system (M := M) (I := I) (κ := κ) hμ).Name)
    (hE : ∀ π ∈ SupportFilter.Fix p.range, π • E = E)
    (t : Diagram M I) (ht : t.sub b = p)
    (d : CohenForcing.Condition I κ) (hd : d.support ⊆ t.range)
    (j : I) (hj : j ∈ t.range)
    (hout : ∀ z : Poset M I κ, z ≤ (d,t) →
      ¬ (system hμ).atomic.MemF z (labelClass hμ c E j) (localList hμ c hcard p)) :
    ∃ (d' : K → CohenForcing.Condition I κ) (σ : ∀ i, LocalName hμ c (r.sub (m i))),
      (∀ i, (d' i).support ⊆ (r.sub (m i)).range) ∧
      (∀ i, (d' i).restrict p.range = d.restrict p.range) ∧
      (∀ i z, (system hμ).Forces ![(σ i).name,labelSet hμ c,E] z (SetLanguage.isClass 0 1 2)) ∧
      ∀ i, OutsideLocal hμ c hcard p (r.sub (m i)) (d' i) (σ i) := by
  let S := system (M := M) (I := I) (κ := κ) hμ
  have hroots (i : K) : (r.sub (m i)).sub b = p := by rw [Diagram.sub_sub,hm i,hp]
  choose π hπ hfix using fun i : K =>
    Diagram.permutation_over_root hsize t (r.sub (m i)) p b ht (hroots i)
  have hip (i : K) : r.sub (m i) ≤ p := ⟨b,hroots i⟩
  have jmem (i : K) : π i j ∈ (r.sub (m i)).range := by
    rw [← hπ i,Diagram.range_permute]
    exact Set.mem_image_of_mem (π i) hj
  let σ (i : K) := localLabelClass hμ c (r.sub (m i)) E
    (supported_mono hμ (hip i) E hE) (π i j) (jmem i)
  refine ⟨fun i => d.permute (π i),σ,?_,?_,?_,?_⟩
  · intro i
    rw [CohenForcing.Condition.support_permute,← hπ i,Diagram.range_permute]
    exact Set.image_mono hd
  · intro i
    exact CohenForcing.Condition.restrict_permute_of_fixes _ _ (hfix i)
  · intro i z
    exact forces_localLabelClass_isClass hμ c _ E _ _ _ z
  · intro i z hz hzmem
    have hπp : π i ∈ SupportFilter.Fix p.range := (SupportFilter.mem_Fix _ _).mpr (hfix i)
    have he : π i • E = E := hE _ hπp
    have hn : π i • labelClass hμ c E j = (σ i).name := by
      change π i • labelClass hμ c E j = labelClass hμ c E (π i j)
      rw [labelClass_move,he]
    have hl : π i • localList hμ c hcard p = localList hμ c hcard p :=
      localList_fixed hμ c hcard p (π i) hπp
    have hmove : S.move (π i) ((d,t) : Poset M I κ) = (d.permute (π i),r.sub (m i)) := by
      rw [move_coe]
      change ((d.permute (π i),t.permute (π i)) : Poset M I κ) = _
      rw [hπ i]
    apply hout ((S.move (π i)).symm z)
    · apply (S.move (π i)).le_iff_le.mp
      rw [OrderIso.apply_symm_apply,hmove]
      exact hz
    · apply (S.mem_symmetry (π i) ((S.move (π i)).symm z) _ _).mpr
      rw [OrderIso.apply_symm_apply,hn,hl]
      exact hzmem

/-- A uniform family of genuinely dense Cohen requirements which forces the
lower exact-fiber bound. The requirements are built from transported copies
of one outside witness. Every filter meeting them has the displayed
embedding; no ambient filter is presumed to meet all ambient dense sets. -/
theorem classFiber_dense_lower [Infinite M] [Infinite I]
    (hcard : Cardinal.mk M ≤ μ) (hsize : Cardinal.mk M < Cardinal.mk I)
    (hmerger : HasFiniteMergers M) {q : Diagram M I} (w : Vertex q) (e b : M)
    {K : Type u} [Uncountable K] (m : K × K → M)
    (hmb : ∀ i, m i*b = w.index*e)
    (hm : ∀ i (n : M), n ∣ w.index ∧ n ∣ m i ↔ n ∈ w.ideal.carrier)
    (hinter : ∀ i (n : M), n ∣ w.index → n ∉ w.ideal.carrier →
      ∀ z : M, n ∣ z ∧ m i ∣ z ↔ w.index*e ∣ z)
    (hind : ∀ i j, i ≠ j → ∀ z : M, m i ∣ z ∧ m j ∣ z ↔ w.index*e ∣ z)
    (E : (system (M := M) (I := I) (κ := κ) hμ).Name)
    (hE : ∀ π ∈ SupportFilter.Fix (q.sub e).range, π • E = E)
    (t : Diagram M I) (ht : t.sub b = q.sub e)
    (d : CohenForcing.Condition I κ) (hd : d.support ⊆ t.range)
    (j : I) (hj : j ∈ t.range)
    (hout : ∀ z : Poset M I κ, z ≤ (d,t) →
      ¬ (system hμ).atomic.MemF z (labelClass hμ c E j) (localList hμ c hcard (q.sub e))) :
    ∃ D : K → Set (CohenForcing.Condition I κ), (∀ i, Dense (D i)) ∧
      ∀ F : GenericFilter (CohenForcing.Condition I κ), d ∈ F →
        (∀ i, ∃ a, a ∈ F ∧ a ∈ D i) →
        Nonempty (K ↪ (eligibleSystem hμ c hcard hsize hmerger F q E
          (supported_mono hμ (q.self_le_sub e) E hE)).vertexFiber w) := by
  have hp : w.diagram.sub (w.index*e) = q.sub e := by rw [← Diagram.sub_sub,w.root]
  obtain ⟨d',σ,hs,hroot,hσ,hout'⟩ := outsideClass_copies hμ c hcard hsize
    (q.sub e) w.diagram w.index e b hp m hmb E hE t ht d hd j hj hout
  have hdisj : Pairwise (fun i k : K × K => Disjoint
      ((d' i).support \ (q.sub e).range) ((d' k).support \ (q.sub e).range)) := by
    intro i k hik
    rw [Set.disjoint_left]
    rintro z ⟨hzi,hzp⟩ ⟨hzk,_⟩
    apply hzp
    have hi := w.diagram.range_inter_sub (m i) (m k) (w.index*e) (hind i k hik)
    rw [hp] at hi
    exact hi ▸ ⟨hs i hzi,hs k hzk⟩
  let D (i : K) := CohenForcing.Condition.probeDenseSet
    (d.restrict (q.sub e).range) (fun k : K => d' (i,k))
  refine ⟨D,?_,?_⟩
  · intro i
    apply CohenForcing.Condition.probeDenseSet_dense (q.sub e).range
      (d.restrict (q.sub e).range) (fun k : K => d' (i,k)) (fun k => hroot (i,k))
    intro x y hxy
    exact hdisj (fun h => hxy (congrArg Prod.snd h))
  · intro F hdF hmeets
    have hits (i : K) : ∃ k : K, d' (i,k) ∈ F := by
      obtain ⟨k,a,ha,hle⟩ := CohenForcing.Condition.meets_probe F
        (F.lower (d.le_restrict _) hdF) (hmeets i)
      exact ⟨k,F.lower hle ha⟩
    choose k hk using hits
    let hEq := supported_mono hμ (q.self_le_sub e) E hE
    refine ⟨classFiberEmbedding hμ c hcard hsize hmerger F w (q.sub e) e b hp
      (fun i : K => m (i,k i)) (fun i => hmb (i,k i))
      (fun i => hm (i,k i)) (fun i => hinter (i,k i)) ?_
      E hEq (fun i => σ (i,k i)) ?_ (fun i => d' (i,k i)) hk (fun i => hout' (i,k i))⟩
    · intro i j hij
      exact hind (i,k i) (j,k j) (fun h => hij (congrArg Prod.fst h))
    · intro i
      exact ⟨d' (i,k i),hk i,hσ (i,k i) (d' (i,k i),w.diagram.sub (m (i,k i)))⟩

end
end PartitionConsistency.ProductForcing

end OAI