import OAI.SetTheory.PartitionPrinciple.Forcing.GroundUnionSizeWitnesses
import OAI.SetTheory.PartitionPrinciple.Geometry.GroundInitialCompressionOrigin

namespace OAI

namespace PartitionPilot.Forcing

namespace GroundBelow
open SetFormula
universe u
variable {M : TransitiveGround.{u}}
variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
variable (unions : Realize M.sets SetFormula.union Fin.elim0)
variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
variable (choice : Realize M.sets SetFormula.choice Fin.elim0)
include pairing unions powers separation choice

theorem sUnion {R K : ZFSet.{u}} (hR : R ∈ M.sets) (hK : K ∈ M.sets)
    (ordinal : ordinalSetProperty K) (regular : GroundRegular M K) (strong : GroundStrongLimit M K)
    (indices : GroundBelow M R K) (small : ∀ A ∈ R, GroundBelow M A K) :
    GroundBelow M R.sUnion K := by
  obtain ⟨D, hD, witness⟩ := M.regular_union_embeds_product
    pairing unions powers separation choice hR hK ordinal regular indices small
  have hDM := M.transitive hK hD
  have smallD := GroundBelow.of_member pairing unions powers separation hK hD
  have product := GroundBelow.product pairing unions powers separation hR hDM hK ordinal strong indices smallD
  exact product.of_embeddable pairing unions powers separation (M.union_mem unions hR)
    (M.prod_mem pairing unions powers separation hR hDM) hK witness

theorem indexed_sUnion {I Q F K : ZFSet.{u}}
    (hI : I ∈ M.sets) (hQ : Q ∈ M.sets) (hF : F ∈ M.sets) (hK : K ∈ M.sets)
    (ordinal : ordinalSetProperty K) (regular : GroundRegular M K) (strong : GroundStrongLimit M K)
    (indices : GroundBelow M I K) (family : ZFSet.IsFunc I Q F)
    (small : ∀ i A, ZFSet.pair i A ∈ F → GroundBelow M A K) :
    GroundBelow M (relationImage I Q F).sUnion K := by
  have hR := M.relationImage_mem separation hI hQ hF
  have indexImage := indices.function_image pairing unions powers separation choice hI hQ hK hF family
  apply GroundBelow.sUnion pairing unions powers separation choice hR hK ordinal regular strong indexImage
  intro A hA
  obtain ⟨_, i, _, entry⟩ := (mem_relationImage I Q F A).1 hA
  exact small i A entry

end GroundBelow

namespace GroundBelow
open SetFormula
universe u
variable {M : TransitiveGround.{u}} {K : ZFSet.{u}}
variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
variable (unions : Realize M.sets SetFormula.union Fin.elim0)
variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
variable (infinite : Realize M.sets infinity Fin.elim0)
variable (choice : Realize M.sets SetFormula.choice Fin.elim0)

theorem of_countable {A : ZFSet.{u}} (omega : ZFSet.omega ∈ K)
    (small : M.groundEmbeddable A ZFSet.omega) : GroundBelow M A K := ⟨ZFSet.omega, omega, small⟩

include pairing unions powers separation infinite

theorem singleton {a : ZFSet.{u}} (hK : K ∈ M.sets) (omega : ZFSet.omega ∈ K)
    (ha : a ∈ M.sets) : GroundBelow M ({a} : ZFSet.{u}) K := by
  have hEmpty := M.empty_mem ⟨K, hK⟩
  apply of_countable omega
  simpa using M.groundEmbeddable_insert pairing unions powers separation infinite hEmpty ha
    (M.empty_groundEmbeddable ZFSet.omega ⟨K, hK⟩)

theorem unorderedPair {a b : ZFSet.{u}} (hK : K ∈ M.sets) (omega : ZFSet.omega ∈ K)
    (ha : a ∈ M.sets) (hb : b ∈ M.sets) : GroundBelow M ({a, b} : ZFSet.{u}) K := by
  have hEmpty := M.empty_mem ⟨K, hK⟩
  have first := M.groundEmbeddable_insert pairing unions powers separation infinite hEmpty hb
    (M.empty_groundEmbeddable ZFSet.omega ⟨K, hK⟩)
  have ground := M.insert_mem pairing unions hb hEmpty
  apply of_countable omega
  simpa using M.groundEmbeddable_insert pairing unions powers separation infinite ground ha first

include choice

theorem binary_union {A B : ZFSet.{u}}
    (hA : A ∈ M.sets) (hB : B ∈ M.sets) (hK : K ∈ M.sets) (omega : ZFSet.omega ∈ K)
    (ordinal : ordinalSetProperty K) (regular : GroundRegular M K) (strong : GroundStrongLimit M K)
    (first : GroundBelow M A K) (second : GroundBelow M B K) : GroundBelow M (A ∪ B) K := by
  have result := sUnion pairing unions powers separation choice (M.unorderedPair_mem pairing hA hB) hK
    ordinal regular strong (unorderedPair pairing unions powers separation infinite hK omega hA hB)
    (fun X hX => (ZFSet.mem_pair.1 hX).elim (fun equal => equal ▸ first) (fun equal => equal ▸ second))
  simpa only [ZFSet.sUnion_pair] using result

theorem insert {A a : ZFSet.{u}}
    (hA : A ∈ M.sets) (ha : a ∈ M.sets) (hK : K ∈ M.sets) (omega : ZFSet.omega ∈ K)
    (ordinal : ordinalSetProperty K) (regular : GroundRegular M K) (strong : GroundStrongLimit M K)
    (small : GroundBelow M A K) : GroundBelow M (Insert.insert a A) K := by
  have hs : ({a} : ZFSet.{u}) ∈ M.sets := by
    simpa only [ZFSet.pair_eq_singleton] using M.unorderedPair_mem pairing ha ha
  have result := binary_union pairing unions powers separation infinite choice hs hA hK omega
    ordinal regular strong (singleton pairing unions powers separation infinite hK omega ha) small
  have equal : ({a} : ZFSet.{u}) ∪ A = Insert.insert a A := by
    apply ZFSet.ext
    intro x
    simp only [ZFSet.mem_union, ZFSet.mem_singleton, ZFSet.mem_insert_iff]
  exact equal ▸ result

end GroundBelow

namespace GroundBelow
open SetFormula
universe u
variable {M : TransitiveGround.{u}} {K : ZFSet.{u}}
variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
variable (unions : Realize M.sets SetFormula.union Fin.elim0)
variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
variable (choice : Realize M.sets SetFormula.choice Fin.elim0)
include pairing unions powers separation choice

theorem indexedAttachmentDomain {I Qs : ZFSet.{u}}
    (hI : I ∈ M.sets) (hQs : Qs ∈ M.sets) (hK : K ∈ M.sets)
    (ordinal : ordinalSetProperty K) (regular : GroundRegular M K) (strong : GroundStrongLimit M K)
    (family : FunctionGraphOn I Qs) (indices : GroundBelow M I K)
    (templates : ∀ i Q, ZFSet.pair i Q ∈ Qs → GroundBelow M Q K) :
    GroundBelow M (Forcing.indexedAttachmentDomain I Qs) K := by
  have hBound := M.union_mem unions (M.union_mem unions hQs)
  have hRange := M.relationImage_mem separation hI hBound hQs
  have points := GroundBelow.indexed_sUnion pairing unions powers separation choice hI hBound hQs hK
    ordinal regular strong indices family.to_isFunc templates
  have small := GroundBelow.product pairing unions powers separation hI (M.union_mem unions hRange)
    hK ordinal strong indices points
  apply small.restrict separation (M.indexedAttachmentDomain_mem pairing unions powers separation hI hQs) hK
  intro z hz
  obtain ⟨i, hi, q, rfl, Q, entry, hq⟩ := (mem_indexedAttachmentDomain I Qs z).1 hz
  exact ZFSet.pair_mem_prod.2 ⟨hi, ZFSet.mem_sUnion.2
    ⟨Q, (mem_relationImage I Qs.sUnion.sUnion Qs Q).2
      ⟨pair_second_mem_doubleUnion entry, i, hi, entry⟩, hq⟩⟩

theorem indexedAttachmentFresh {I Qs rs As : ZFSet.{u}}
    (hI : I ∈ M.sets) (hQs : Qs ∈ M.sets) (hrs : rs ∈ M.sets) (hAs : As ∈ M.sets)
    (hK : K ∈ M.sets) (ordinal : ordinalSetProperty K) (regular : GroundRegular M K)
    (strong : GroundStrongLimit M K) (family : FunctionGraphOn I Qs) (indices : GroundBelow M I K)
    (templates : ∀ i Q, ZFSet.pair i Q ∈ Qs → GroundBelow M Q K) :
    GroundBelow M (Forcing.indexedAttachmentFresh I Qs rs As) K :=
  (GroundBelow.indexedAttachmentDomain pairing unions powers separation choice hI hQs hK
    ordinal regular strong family indices templates).restrict separation
      (M.indexedAttachmentFresh_mem pairing unions powers separation hI hQs hrs hAs) hK
      (indexedAttachmentFresh_subset I Qs rs As)

variable (infinite : Realize M.sets infinity Fin.elim0)
include infinite

theorem taggedExtension {P N : ZFSet.{u}}
    (hP : P ∈ M.sets) (hN : N ∈ M.sets) (hK : K ∈ M.sets) (omega : ZFSet.omega ∈ K)
    (ordinal : ordinalSetProperty K) (regular : GroundRegular M K) (strong : GroundStrongLimit M K)
    (old : GroundBelow M P K) (fresh : GroundBelow M N K) :
    GroundBelow M (Forcing.taggedExtension P N) K := by
  have hSingle : ({P} : ZFSet.{u}) ∈ M.sets := by
    simpa only [ZFSet.pair_eq_singleton] using M.unorderedPair_mem pairing hP hP
  exact GroundBelow.binary_union pairing unions powers separation infinite choice hP
    (M.prod_mem pairing unions powers separation hSingle hN) hK omega ordinal regular strong old
    (GroundBelow.product pairing unions powers separation hSingle hN hK ordinal strong
      (GroundBelow.singleton pairing unions powers separation infinite hK omega hP) fresh)

theorem batchCarrier {P rP μP I Qs rs μs As Es Fs Ss : ZFSet.{u}}
    (d : AttachmentBatchInputs P rP μP I Qs rs μs As Es Fs Ss)
    (hP : P ∈ M.sets) (hI : I ∈ M.sets) (hQs : Qs ∈ M.sets)
    (hrs : rs ∈ M.sets) (hAs : As ∈ M.sets) (hK : K ∈ M.sets) (omega : ZFSet.omega ∈ K)
    (ordinal : ordinalSetProperty K) (regular : GroundRegular M K) (strong : GroundStrongLimit M K)
    (old : GroundBelow M P K) (indices : GroundBelow M I K)
    (templates : ∀ i Q, ZFSet.pair i Q ∈ Qs → GroundBelow M Q K) :
    GroundBelow M d.batchCarrier K :=
  GroundBelow.taggedExtension pairing unions powers separation choice infinite hP
    (M.indexedAttachmentFresh_mem pairing unions powers separation hI hQs hrs hAs)
    hK omega ordinal regular strong old
    (GroundBelow.indexedAttachmentFresh pairing unions powers separation choice hI hQs hrs hAs hK
      ordinal regular strong d.spaces indices templates)

end GroundBelow

namespace GroundCompressionState
open SetFormula
universe u
variable {M : TransitiveGround.{u}}
variable {P0 r0 μ0 A0 τ I Sources Reps G m inv one T Filters : ZFSet.{u}}
variable {seed : FixedCompressionSeed P0 r0 μ0 A0 τ I Sources Reps G m inv one T Filters}
variable (state : GroundCompressionState M seed)
variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
variable (unions : Realize M.sets SetFormula.union Fin.elim0)
variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
variable (infinite : Realize M.sets infinity Fin.elim0)
variable (choice : Realize M.sets SetFormula.choice Fin.elim0)
include pairing unions powers separation infinite choice

theorem currentCarrier_below {P r μ K : ZFSet.{u}}
    (hK : K ∈ M.sets) (conditions : GroundInaccessibleConditions M K)
    (constant : RecursiveTemplateConstancy P r μ state.data)
    (templates : GroundBelow M P K) (old : GroundBelow M state.data.D K)
    (indices : GroundBelow M state.data.J K) : GroundBelow M state.data.currentCarrier K := by
  apply GroundBelow.batchCarrier pairing unions powers separation choice infinite state.batch
    state.ground.carrier state.ground.indices state.ground.spaces state.ground.relations state.ground.anchors
    hK conditions.2.1 conditions.1 conditions.2.2.1 conditions.2.2.2 old indices
  intro i Q entry
  obtain rfl := ((constant.space_entry_iff i Q).1 entry).2
  exact templates

theorem canonical_iterate_below
    (hI : I ∈ M.sets) (hSources : Sources ∈ M.sets) (hReps : Reps ∈ M.sets)
    (hG : G ∈ M.sets) (hT : T ∈ M.sets)
    {P r μ K : ZFSet.{u}} (hK : K ∈ M.sets) (conditions : GroundInaccessibleConditions M K)
    (constant : RecursiveTemplateConstancy P r μ state.data)
    (templates : GroundBelow M P K) (old : GroundBelow M state.data.D K)
    (indices : GroundBelow M state.data.J K) (tasks : GroundBelow M I K) (n : Nat) :
    GroundBelow M (state.data.iterate M I Sources Reps G T n).D K ∧
      GroundBelow M (state.data.iterate M I Sources Reps G T n).J K := by
  induction n with
  | zero => exact ⟨old, indices⟩
  | succ n ih =>
    obtain ⟨current, equal⟩ := state.canonical_iterate_valid
      pairing unions powers separation hI hSources hReps hG hT n
    have currentOld : GroundBelow M current.data.D K := by rw [equal]; exact ih.1
    have currentIndices : GroundBelow M current.data.J K := by rw [equal]; exact ih.2
    have currentConstant : RecursiveTemplateConstancy P r μ current.data := by
      rw [equal]
      exact constant.iterate M I Sources Reps G T n
    rw [RecursiveStateData.iterate_succ, ← equal]
    change GroundBelow M current.data.currentCarrier K ∧
      GroundBelow M (recursiveAttachmentIndices I current.data.J current.data.D
        current.data.Fs.sUnion.sUnion Sources current.data.Fs) K
    refine ⟨current.currentCarrier_below pairing unions powers separation infinite choice
      hK conditions currentConstant templates currentOld currentIndices, ?_⟩
    have bound := GroundBelow.product pairing unions powers separation hI current.ground.indices hK
      conditions.1 conditions.2.2.2 tasks currentIndices
    exact bound.restrict separation
      (M.recursiveAttachmentIndices_mem pairing unions powers separation hI current.ground.indices
        current.ground.carrier (M.union_mem unions (M.union_mem unions current.ground.filters))
        hSources current.ground.filters) hK (recursiveAttachmentIndices_subset _ _ _ _ _ _)

theorem canonical_currentCarrier_below
    (hI : I ∈ M.sets) (hSources : Sources ∈ M.sets) (hReps : Reps ∈ M.sets)
    (hG : G ∈ M.sets) (hT : T ∈ M.sets)
    {P r μ K : ZFSet.{u}} (hK : K ∈ M.sets) (conditions : GroundInaccessibleConditions M K)
    (constant : RecursiveTemplateConstancy P r μ state.data)
    (templates : GroundBelow M P K) (old : GroundBelow M state.data.D K)
    (indices : GroundBelow M state.data.J K) (tasks : GroundBelow M I K) (n : Nat) :
    GroundBelow M (state.data.iterate M I Sources Reps G T n).currentCarrier K :=
  (state.canonical_iterate_below pairing unions powers separation infinite choice
    hI hSources hReps hG hT hK conditions constant templates old indices tasks (n + 1)).1

end GroundCompressionState

namespace TransitiveGround
open SetFormula
universe u
variable (M : TransitiveGround.{u})

theorem initialCompressionData_below
    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
    (unions : Realize M.sets SetFormula.union Fin.elim0)
    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
    (infinite : Realize M.sets infinity Fin.elim0)
    (choice : Realize M.sets SetFormula.choice Fin.elim0)
    {P G r μ A Labels K : ZFSet.{u}}
    (hP : P ∈ M.sets) (hG : G ∈ M.sets) (hr : r ∈ M.sets) (hμ : μ ∈ M.sets)
    (hA : A ∈ M.sets) (hLabels : Labels ∈ M.sets) (hK : K ∈ M.sets)
    (meet : MeetOrderCode P r μ) (conditions : GroundInaccessibleConditions M K)
    (points : GroundBelow M P K) (labels : GroundBelow M Labels K) :
    GroundBelow M (M.initialCompressionData P G r μ A Labels).currentCarrier K := by
  let I := M.groundEligibleTasks P G r μ A Labels
  let Sources := literalTaskSourceGraph I P (M.groundRelations P P) (M.groundMeetFilters P r μ) Labels
  obtain ⟨hI, hQs, hrs, _, fields⟩ := M.groundEligibleTaskFields
    pairing unions powers separation hP hG hr hμ hA hLabels meet
  have hSources : Sources ∈ M.sets := (fields 0).1
  have indices := M.groundEligibleTasks_below pairing unions powers separation
    hP hG hr hμ hA hLabels hK meet conditions.1 conditions.2.2.2 points labels
  have fresh : GroundBelow M
      (indexedAttachmentFresh I (constantFamilyGraph I P) (constantFamilyGraph I r) Sources) K := by
    apply GroundBelow.indexedAttachmentFresh pairing unions powers separation choice hI hQs hrs hSources hK
      conditions.1 conditions.2.2.1 conditions.2.2.2
      ⟨_, constantFamilyGraph_function I P⟩ indices
    intro i Q entry
    obtain rfl := ((pair_mem_constantFamilyGraph I P i Q).1 entry).2
    exact points
  exact GroundBelow.taggedExtension pairing unions powers separation choice infinite hP
    (M.indexedAttachmentFresh_mem pairing unions powers separation hI hQs hrs hSources)
    hK conditions.2.1 conditions.1 conditions.2.2.1 conditions.2.2.2 points fresh

end TransitiveGround

open SetFormula
universe u

namespace TransitiveGround
variable (M : TransitiveGround.{u})

theorem history_field_union_below
    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
    (unions : Realize M.sets SetFormula.union Fin.elim0)
    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
    (collection : CollectionSchema M.sets) (infinite : Realize M.sets infinity Fin.elim0)
    (choice : Realize M.sets SetFormula.choice Fin.elim0)
    {K history U : ZFSet.{u}} (hK : K ∈ M.sets) (conditions : GroundInaccessibleConditions M K)
    (hHistory : history ∈ M.sets) (states : Nat → RecursiveStateData.{u})
    (entries : ∀ n y, ZFSet.pair (natSetCode n) y ∈ history ↔ y = (states n).code)
    (j : Fin 13) (small : ∀ n, GroundBelow M ((states n).field j) K)
    (code : NatUnionCode (fun n => (states n).field j) U) : GroundBelow M U K := by
  have hOmega := M.omega_mem separation infinite
  obtain ⟨family, hFamily, function, actual⟩ := M.exists_groundStateFieldFamily
    pairing separation collection hOmega hHistory states entries j
  have hBound := M.union_mem unions (M.union_mem unions hFamily)
  have sizes : ∀ i A, ZFSet.pair i A ∈ family → GroundBelow M A K := by
    intro i A entry
    obtain ⟨n, rfl⟩ := (mem_omega_iff_natSetCode i).1 (function.pair_source entry)
    rw [(actual n A).1 entry]
    exact small n
  have bound := GroundBelow.indexed_sUnion pairing unions powers separation choice hOmega hBound hFamily hK
    conditions.1 conditions.2.2.1 conditions.2.2.2
    (GroundBelow.of_member pairing unions powers separation hK conditions.2.1) function.to_isFunc sizes
  have same : U = (relationImage ZFSet.omega family.sUnion.sUnion family).sUnion := by
    apply ZFSet.ext
    intro x
    rw [code x, ZFSet.mem_sUnion]
    constructor
    · rintro ⟨n, hx⟩
      have entry := (actual n ((states n).field j)).2 rfl
      exact ⟨(states n).field j,
        (mem_relationImage _ _ _ _).2
          ⟨pair_second_mem_doubleUnion entry, natSetCode n, natSetCode_mem_omega n, entry⟩, hx⟩
    · rintro ⟨A, hA, hx⟩
      obtain ⟨_, i, hi, entry⟩ := (mem_relationImage _ _ _ _).1 hA
      obtain ⟨n, rfl⟩ := (mem_omega_iff_natSetCode i).1 hi
      refine ⟨n, ?_⟩
      change x ∈ (states n).field j
      exact (actual n A).1 entry ▸ hx
  exact same.symm ▸ bound

end TransitiveGround

namespace GroundCompressionState
variable {M : TransitiveGround.{u}}
variable {P0 r0 μ0 A0 τ I Sources Reps G m inv one T Filters : ZFSet.{u}}
variable {seed : FixedCompressionSeed P0 r0 μ0 A0 τ I Sources Reps G m inv one T Filters}
variable (state : GroundCompressionState M seed)

theorem union_below (data : GroundCompressionUnionData M state.data I Sources Reps G m one T)
    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
    (unions : Realize M.sets SetFormula.union Fin.elim0)
    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
    (collection : CollectionSchema M.sets) (infinite : Realize M.sets infinity Fin.elim0)
    (choice : Realize M.sets SetFormula.choice Fin.elim0)
    (hI : I ∈ M.sets) (hSources : Sources ∈ M.sets) (hReps : Reps ∈ M.sets)
    (hG : G ∈ M.sets) (hT : T ∈ M.sets)
    {P r μ K : ZFSet.{u}} (hK : K ∈ M.sets) (conditions : GroundInaccessibleConditions M K)
    (constant : RecursiveTemplateConstancy P r μ state.data)
    (templates : GroundBelow M P K) (old : GroundBelow M state.data.D K)
    (indices : GroundBelow M state.data.J K) (tasks : GroundBelow M I K) :
    GroundBelow M (data.fields 0) K := by
  obtain ⟨history, hHistory, _, entries, _, _⟩ := state.exists_groundHistory
    pairing unions powers separation collection infinite hI hSources hReps hG hT
  exact M.history_field_union_below pairing unions powers separation collection infinite choice
    hK conditions hHistory (state.data.iterate M I Sources Reps G T) entries 0
    (fun n => (state.canonical_iterate_below pairing unions powers separation infinite choice
      hI hSources hReps hG hT hK conditions constant templates old indices tasks n).1)
    (data.fieldUnion 0)

end GroundCompressionState

namespace GroundCompressionOrigin
variable {M : TransitiveGround.{u}} {initial : RecursiveStateData.{u}}
variable {P0 r0 μ0 A0 τ I Sources Reps G m inv one T Filters : ZFSet.{u}}
variable (origin : GroundCompressionOrigin M initial P0 r0 μ0 A0 τ I Sources Reps G m inv one T Filters)

include origin in
theorem union_below (data : GroundCompressionUnionData M initial I Sources Reps G m one T)
    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
    (unions : Realize M.sets SetFormula.union Fin.elim0)
    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
    (collection : CollectionSchema M.sets) (infinite : Realize M.sets infinity Fin.elim0)
    (choice : Realize M.sets SetFormula.choice Fin.elim0)
    (hI : I ∈ M.sets) (hSources : Sources ∈ M.sets) (hReps : Reps ∈ M.sets)
    (hG : G ∈ M.sets) (hT : T ∈ M.sets)
    {P r μ K : ZFSet.{u}} (hK : K ∈ M.sets) (conditions : GroundInaccessibleConditions M K)
    (constant : RecursiveTemplateConstancy P r μ initial)
    (templates : GroundBelow M P K) (old : GroundBelow M initial.D K)
    (indices : GroundBelow M initial.J K) (tasks : GroundBelow M I K) :
    GroundBelow M (data.fields 0) K := by
  obtain ⟨seed, state, equal⟩ := origin
  cases equal
  exact state.union_below data pairing unions powers separation collection infinite choice
    hI hSources hReps hG hT hK conditions constant templates old indices tasks

end GroundCompressionOrigin

namespace TransitiveGround
variable (M : TransitiveGround.{u})

theorem initialCompressionUnion_below
    {P G r μ A Labels τ Sources Reps m inv one T Filters K : ZFSet.{u}}
    (origin : GroundCompressionOrigin M (M.initialCompressionData P G r μ A Labels)
      P r μ A τ (M.groundEligibleTasks P G r μ A Labels) Sources Reps G m inv one T Filters)
    (data : GroundCompressionUnionData M (M.initialCompressionData P G r μ A Labels)
      (M.groundEligibleTasks P G r μ A Labels) Sources Reps G m one T)
    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
    (unions : Realize M.sets SetFormula.union Fin.elim0)
    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
    (collection : CollectionSchema M.sets) (infinite : Realize M.sets infinity Fin.elim0)
    (choice : Realize M.sets SetFormula.choice Fin.elim0)
    (hP : P ∈ M.sets) (hG : G ∈ M.sets) (hr : r ∈ M.sets) (hμ : μ ∈ M.sets)
    (hA : A ∈ M.sets) (hLabels : Labels ∈ M.sets) (hSources : Sources ∈ M.sets)
    (hReps : Reps ∈ M.sets) (hT : T ∈ M.sets) (hK : K ∈ M.sets)
    (meet : MeetOrderCode P r μ) (conditions : GroundInaccessibleConditions M K)
    (points : GroundBelow M P K) (labels : GroundBelow M Labels K) :
    GroundBelow M (data.fields 0) K := by
  have hI := M.groundEligibleTasks_mem pairing unions powers separation hP hG hr hμ hA hLabels meet
  have tasks := M.groundEligibleTasks_below pairing unions powers separation
    hP hG hr hμ hA hLabels hK meet conditions.1 conditions.2.2.2 points labels
  exact origin.union_below data pairing unions powers separation collection infinite choice
    hI hSources hReps hG hT hK conditions
    (M.initialCompressionData_template_constancy P G r μ A Labels) points points tasks tasks

end TransitiveGround

end PartitionPilot.Forcing

end OAI