lean/OAI/SetTheory/PartitionPrinciple/Geometry/GroundBatchEmbeddingRecognition.lean

import OAI.SetTheory.PartitionPrinciple.Definability.GroundLiftedCompressionFormulas
import OAI.SetTheory.PartitionPrinciple.Definability.RecursivePrimitiveFormulas
import OAI.SetTheory.PartitionPrinciple.Geometry.GroundBatchAttachment

namespace OAI

namespace PartitionPilot.Forcing

namespace GroundDefinableFunction
open SetFormula
universe u

def withAux {M : TransitiveGround.{u}} {n}
    {a f : (Fin n → ZFSet.{u}) → ZFSet.{u}}
    (aux : GroundDefinableFunction M a) (body : SetFormula (n + 2))
    (closed : ∀ env, (∀ i, env i ∈ M.sets) → f env ∈ M.sets)
    (correct : ∀ env, (∀ i, env i ∈ M.sets) → ∀ z ∈ M.sets,
      Realize M.sets body (extend (a env) (extend z env)) ↔ z = f env) :
    GroundDefinableFunction M f where
  formula := ex (.conj
    (SetFormula.reindex (extend 0 (fun i => i.succ.succ)) aux.formula) body)
  closed := closed
  correct := by
    intro env members z hz
    simp only [realize_ex, Realize]
    constructor
    · rintro ⟨value, hvalue, specified, result⟩
      have equal : value = a env := by
        apply (aux.correct env members value hvalue).1
        have meaning := (realize_reindex M.sets _ aux.formula _).1 specified
        rw [map_extend] at meaning
        exact meaning
      subst value
      exact (correct env members z hz).1 result
    · intro equal
      refine ⟨a env, aux.closed env members, ?_, (correct env members z hz).2 equal⟩
      rw [realize_reindex, map_extend]
      exact (aux.correct env members (a env) (aux.closed env members)).2 rfl

def withAuxFamily {M : TransitiveGround.{u}} {n k}
    {a : Fin k → (Fin n → ZFSet.{u}) → ZFSet.{u}}
    {f : (Fin n → ZFSet.{u}) → ZFSet.{u}}
    (aux : ∀ j, GroundDefinableFunction M (a j)) (body : SetFormula (n + 1 + k))
    (closed : ∀ env, (∀ i, env i ∈ M.sets) → f env ∈ M.sets)
    (correct : ∀ env, (∀ i, env i ∈ M.sets) → ∀ z ∈ M.sets,
      Realize M.sets body (extendMany k (fun j => a j env) (extend z env)) ↔ z = f env) :
    GroundDefinableFunction M f where
  formula := exBlock k (.conj
    (conjBlock k (fun j => SetFormula.reindex
      (extend (prefixIndex (n + 1) k j) (fun i => suffixIndex (n + 1) k i.succ)) (aux j).formula)) body)
  closed := closed
  correct := by
    intro env members z hz
    rw [realize_exBlock]
    constructor
    · rintro ⟨fields, fieldMembers, clauses, result⟩
      have each := (realize_conjBlock M.sets _ _ _).1 clauses
      have values : fields = fun j => a j env := by
        funext j
        have meaning := (realize_reindex M.sets _ _ _).1 (each j)
        rw [map_extend] at meaning
        simp only [extendMany_prefix, extendMany_suffix] at meaning
        exact ((aux j).correct env members (fields j) (fieldMembers j)).1 meaning
      exact (correct env members z hz).1 (values ▸ result)
    · intro equal
      let fields : Fin k → ZFSet.{u} := fun j => a j env
      have fieldMembers : ∀ j, fields j ∈ M.sets := fun j => (aux j).closed env members
      refine ⟨fields, fieldMembers, ?_, (correct env members z hz).2 equal⟩
      apply (realize_conjBlock M.sets _ _ _).2
      intro j
      rw [realize_reindex, map_extend]
      simp only [extendMany_prefix, extendMany_suffix]
      exact ((aux j).correct env members (fields j) (fieldMembers j)).2 rfl

end GroundDefinableFunction

section
open SetFormula
universe u

namespace SetFormula

def indexedDomainSetFormula {n} (output i qs qb : Fin n) : SetFormula n :=
  exactSetFormula output
    (BoundedFormula.indexedAttachmentDomainEntryFormula 0 i.succ qs.succ qb.succ).toFormula

def batchTemplateSetFormula {n} (output domain carrier p i points es eb fresh : Fin n) : SetFormula n :=
  exactSetFormula output (reindex
    (Fin.cases 0 (Fin.cases domain.succ (Fin.cases carrier.succ (Fin.cases p.succ
      (Fin.cases i.succ (Fin.cases points.succ (Fin.cases es.succ
        (Fin.cases eb.succ (Fin.cases fresh.succ Fin.elim0)))))))))
    BoundedFormula.batchTemplateGraphFormula.toFormula)

end SetFormula

namespace TransitiveGround
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)
include pairing unions powers separation

theorem realize_indexedDomainSetFormula {n} (output i qs qb : Fin n)
    (env : Fin n → ZFSet.{u}) (members : ∀ x, env x ∈ M.sets)
    (bound : env qb = ZFSet.sUnion (ZFSet.sUnion (env qs))) :
    Realize M.sets (indexedDomainSetFormula output i qs qb) env ↔
      env output = indexedAttachmentDomain (env i) (env qs) := by
  apply M.realize_exactBoundedSetFormula output _ env members
    (M.indexedAttachmentDomain_mem pairing unions powers separation (members i) (members qs))
  intro z
  rw [BoundedFormula.truth_indexedAttachmentDomainEntryFormula]
  change (∃ j ∈ env i, ∃ Q ∈ env qb, ∃ q ∈ Q,
    ZFSet.pair j Q ∈ env qs ∧ z = ZFSet.pair j q) ↔ _
  rw [bound, indexedAttachmentDomain, ZFSet.mem_sep]
  constructor
  · intro witness
    refine ⟨?_, witness⟩
    obtain ⟨j, hj, Q, _, q, hq, entry, equal⟩ := witness
    rw [equal]
    exact ZFSet.pair_mem_prod.2 ⟨hj, mem_familyPointBound_of_entry entry hq⟩
  · exact And.right

theorem realize_batchTemplateSetFormula {n}
    (output domain carrier p i qs rs anchors es points eb fresh : Fin n)
    (env : Fin n → ZFSet.{u}) (members : ∀ x, env x ∈ M.sets)
    (domain_eq : env domain = indexedAttachmentDomain (env i) (env qs))
    (fresh_eq : env fresh = indexedAttachmentFresh (env i) (env qs) (env rs) (env anchors))
    (carrier_eq : env carrier = taggedExtension (env p) (env fresh))
    (points_eq : env points = familyPointBound (env qs))
    (base_bound : env eb = ZFSet.sUnion (ZFSet.sUnion (env es))) :
    Realize M.sets (batchTemplateSetFormula output domain carrier p i points es eb fresh) env ↔
      env output = batchAttachmentTemplateGraph (env i) (env p) (env qs) (env rs) (env anchors) (env es) := by
  apply M.realize_exactReindexedBoundedSetFormula output _ _ env members
    (M.batchAttachmentTemplateGraph_mem pairing unions powers separation
      (members i) (members p) (members qs) (members rs) (members anchors) (members es))
  intro z
  rw [BoundedFormula.truth_batchTemplateGraphFormula]
  change (∃ x ∈ env domain, ∃ y ∈ env carrier, z = ZFSet.pair x y ∧
    ((∃ j ∈ env i, ∃ q ∈ env points, x = ZFSet.pair j q ∧
      ∃ ell ∈ env eb, ZFSet.pair j ell ∈ env es ∧ ZFSet.pair q y ∈ ell) ∨
      (x ∈ env fresh ∧ y = ZFSet.pair (env p) x))) ↔ _
  rw [domain_eq, carrier_eq, points_eq, base_bound, fresh_eq]
  dsimp only [batchAttachmentTemplateGraph]
  rw [ZFSet.mem_sep]
  constructor
  · intro witness
    refine ⟨?_, witness⟩
    obtain ⟨x, hx, y, hy, equal, _⟩ := witness
    rw [equal]
    exact ZFSet.pair_mem_prod.2 ⟨hx, hy⟩
  · exact And.right

end TransitiveGround
end

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

noncomputable def definable_sUnion (unions : Realize M.sets SetFormula.union Fin.elim0) :
    GroundDefinableFunction M (fun env : Fin 1 → ZFSet.{u} => ZFSet.sUnion (env 0)) where
  formula := sUnionSetFormula 0 1
  closed := fun _env members => M.union_mem unions (members 0)
  correct := fun env members z hz =>
    M.realize_sUnionSetFormula unions 0 1 (extend z env) (Fin.cases hz members)

noncomputable def definable_doubleUnion (unions : Realize M.sets SetFormula.union Fin.elim0) :
    GroundDefinableFunction M (fun env : Fin 1 → ZFSet.{u} => ZFSet.sUnion (ZFSet.sUnion (env 0))) :=
  (M.definable_sUnion unions).comp (fun _ => M.definable_sUnion unions)

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)
include pairing unions powers separation

noncomputable def definable_taggedExtension : GroundDefinableFunction M
    (fun env : Fin 2 → ZFSet.{u} => taggedExtension (env 0) (env 1)) where
  formula := taggedExtensionSetFormula 0 1 2
  closed := fun _env members => M.taggedExtension_mem pairing unions powers separation (members 0) (members 1)
  correct := fun env members z hz => M.realize_taggedExtensionSetFormula pairing unions powers separation
    0 1 2 (extend z env) (Fin.cases hz members)

noncomputable def definable_canonicalMeet : GroundDefinableFunction M
    (fun env : Fin 2 → ZFSet.{u} => canonicalMeetGraph (env 0) (env 1)) where
  formula := canonicalMeetSetFormula 0 1 2
  closed := fun _env members => M.canonicalMeetGraph_mem pairing unions powers separation (members 0) (members 1)
  correct := fun env members z hz => M.realize_canonicalMeetSetFormula pairing unions powers separation
    0 1 2 (extend z env) (Fin.cases hz members)

noncomputable def definable_recursiveIndices : GroundDefinableFunction M
    (fun env : Fin 6 → ZFSet.{u} => recursiveAttachmentIndices
      (env 0) (env 1) (env 2) (env 3) (env 4) (env 5)) where
  formula := recursiveIndicesSetFormula 0 1 2 3 4 5 6
  closed := fun _env members => M.recursiveAttachmentIndices_mem pairing unions powers separation
    (members 0) (members 1) (members 2) (members 3) (members 4) (members 5)
  correct := fun env members z hz => M.realize_recursiveIndicesSetFormula pairing unions powers separation
    0 1 2 3 4 5 6 (extend z env) (Fin.cases hz members)

noncomputable def definable_codedAttachmentOrder : GroundDefinableFunction M
    (fun env : Fin 6 → ZFSet.{u} => codedAttachmentOrder
      (env 0) (env 1) (env 2) (env 3) (env 4) (env 5)) := by
  let aux := (M.definable_taggedExtension pairing unions powers separation).reindex
    (Fin.cases (0 : Fin 6) (Fin.cases 1 Fin.elim0))
  refine aux.withAux (codedAttachmentOrderSetFormula 1 0 2 3 4 5 6 7) ?_ ?_
  · intro env members
    exact M.codedAttachmentOrder_mem pairing unions powers separation
      (members 0) (members 1) (members 2) (members 3) (members 4) (members 5)
  · intro env members z hz
    exact M.realize_codedAttachmentOrderSetFormula pairing unions powers separation 1 0 2 3 4 5 6 7
      _ (Fin.cases (aux.closed env members) (Fin.cases hz members)) rfl

noncomputable def definable_pairSecondField : GroundDefinableFunction M
    (fun env : Fin 4 → ZFSet.{u} => pairSecondField (env 0) (env 1) (env 2) (env 3)) := by
  let aux := (M.definable_doubleUnion unions).reindex (fun _ : Fin 1 => (3 : Fin 4))
  refine aux.withAux (pairFieldSetFormula false 1 2 3 4 0 5) ?_ ?_
  · intro env members
    exact M.pairFieldGraph_mem pairing unions powers separation false
      (members 0) (members 1) (members 2) (aux.closed env members) (members 3)
  · intro env members z hz
    exact M.realize_pairSecondFieldSetFormula pairing unions powers separation 1 2 3 4 0 5
      _ (Fin.cases (aux.closed env members) (Fin.cases hz members)) rfl

noncomputable def definable_indexedFresh : GroundDefinableFunction M
    (fun env : Fin 4 → ZFSet.{u} => indexedAttachmentFresh (env 0) (env 1) (env 2) (env 3)) := by
  let aux := fun j : Fin 3 => (M.definable_doubleUnion unions).reindex (fun _ : Fin 1 => j.succ)
  refine GroundDefinableFunction.withAuxFamily aux (indexedFreshSetFormula 3 4 5 6 7 0 1 2) ?_ ?_
  · intro env members
    exact M.indexedAttachmentFresh_mem pairing unions powers separation
      (members 0) (members 1) (members 2) (members 3)
  · intro env members z hz
    exact M.realize_indexedFreshSetFormula pairing unions powers separation 3 4 5 6 7 0 1 2 _
      (extendMany_members 3 _ _ (fun j => (aux j).closed env members) (Fin.cases hz members)) rfl rfl rfl

noncomputable def definable_batchInside : GroundDefinableFunction M
    (fun env : Fin 3 → ZFSet.{u} => batchAttachmentInsideGraph (env 0) (env 1) (env 2)) := by
  let aux := fun j : Fin 2 => (M.definable_doubleUnion unions).reindex (fun _ : Fin 1 => j.succ)
  refine GroundDefinableFunction.withAuxFamily aux (batchInsideSetFormula 2 3 4 5 0 1) ?_ ?_
  · intro env members
    exact M.batchAttachmentInsideGraph_mem pairing unions powers separation (members 0) (members 1) (members 2)
  · intro env members z hz
    exact M.realize_batchInsideSetFormula pairing unions powers separation 2 3 4 5 0 1 _
      (extendMany_members 2 _ _ (fun j => (aux j).closed env members) (Fin.cases hz members)) rfl rfl

noncomputable def definable_batchUpper : GroundDefinableFunction M
    (fun env : Fin 4 → ZFSet.{u} => batchAttachmentUpperGraph (env 0) (env 1) (env 2) (env 3)) := by
  let slots : Fin 2 → Fin 4 := Fin.cases 2 (Fin.cases 3 Fin.elim0)
  let aux := fun j : Fin 2 => (M.definable_doubleUnion unions).reindex (fun _ : Fin 1 => slots j)
  refine GroundDefinableFunction.withAuxFamily aux (batchUpperSetFormula 2 3 4 5 6 0 1) ?_ ?_
  · intro env members
    exact M.batchAttachmentUpperGraph_mem pairing unions powers separation
      (members 0) (members 1) (members 2) (members 3)
  · intro env members z hz
    exact M.realize_batchUpperSetFormula pairing unions powers separation 2 3 4 5 6 0 1 _
      (extendMany_members 2 _ _ (fun j => (aux j).closed env members) (Fin.cases hz members)) rfl rfl

noncomputable def definable_batchShadow : GroundDefinableFunction M
    (fun env : Fin 6 → ZFSet.{u} => batchAttachmentShadowGraph
      (env 0) (env 1) (env 2) (env 3) (env 4) (env 5)) := by
  let slots : Fin 4 → Fin 6 := Fin.cases 2 (Fin.cases 3 (Fin.cases 4 (Fin.cases 5 Fin.elim0)))
  let aux := fun j : Fin 4 => (M.definable_doubleUnion unions).reindex (fun _ : Fin 1 => slots j)
  refine GroundDefinableFunction.withAuxFamily aux (batchShadowSetFormula 4 5 6 7 8 9 10 0 1 2 3) ?_ ?_
  · intro env members
    exact M.batchAttachmentShadowGraph_mem pairing unions powers separation
      (members 0) (members 1) (members 2) (members 3) (members 4) (members 5)
  · intro env members z hz
    exact M.realize_batchShadowSetFormula pairing unions powers separation 4 5 6 7 8 9 10 0 1 2 3 _
      (extendMany_members 4 _ _ (fun j => (aux j).closed env members) (Fin.cases hz members)) rfl rfl rfl rfl

end TransitiveGround

section
universe u

theorem batchTemplateGraph_eq_section (I P Qs rs As Es i : ZFSet.{u}) :
    batchTemplateGraph I P Qs rs As Es i =
      indexedRelationSection (familyPointBound Qs)
        (taggedExtension P (indexedAttachmentFresh I Qs rs As))
        (batchAttachmentTemplateGraph I P Qs rs As Es) i := rfl

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

noncomputable def batchEmbeddingFamily (I P Qs rs As Es : ZFSet.{u}) : ZFSet.{u} :=
  M.indexedRelationSections I (familyPointBound Qs)
    (taggedExtension P (indexedAttachmentFresh I Qs rs As))
    (batchAttachmentTemplateGraph I P Qs rs As Es)

theorem batchEmbeddingFamily_spec
    (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)
    {I P Qs rs As Es : ZFSet.{u}} (hI : I ∈ M.sets) (hP : P ∈ M.sets)
    (hQs : Qs ∈ M.sets) (hrs : rs ∈ M.sets) (hAs : As ∈ M.sets) (hEs : Es ∈ M.sets) :
    M.batchEmbeddingFamily I P Qs rs As Es ∈ M.sets ∧
      FunctionGraphOn I (M.batchEmbeddingFamily I P Qs rs As Es) ∧
      ∀ i f, ZFSet.pair i f ∈ M.batchEmbeddingFamily I P Qs rs As Es ↔
        i ∈ I ∧ f = batchTemplateGraph I P Qs rs As Es i := by
  have hN := M.indexedAttachmentFresh_mem pairing unions powers separation hI hQs hrs hAs
  have hL := M.taggedExtension_mem pairing unions powers separation hP hN
  have hB := M.familyPointBound_mem unions hQs
  have hR := M.batchAttachmentTemplateGraph_mem pairing unions powers separation hI hP hQs hrs hAs hEs
  obtain ⟨member, function, entries⟩ := M.indexedRelationSections_spec
    pairing unions powers separation hI hB hL hR
  refine ⟨member, ⟨_, function⟩, ?_⟩
  intro i f
  exact (entries i f).trans (and_congr Iff.rfl (by rw [batchTemplateGraph_eq_section]))

theorem exists_batchAttachment_embedding_family
    (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)
    {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) (hrP : rP ∈ M.sets) (hI : I ∈ M.sets)
    (hQs : Qs ∈ M.sets) (hrs : rs ∈ M.sets) (hμs : μs ∈ M.sets)
    (hAs : As ∈ M.sets) (hEs : Es ∈ M.sets) (hFs : Fs ∈ M.sets)
    (_hSs : Ss ∈ M.sets) :
    d.batchCarrier ∈ M.sets ∧ d.batchOrder ∈ M.sets ∧ d.batchMeetGraph ∈ M.sets ∧
    MeetOrderCode d.batchCarrier d.batchOrder d.batchMeetGraph ∧
    ∃ family ∈ M.sets, FunctionGraphOn I family ∧
      (∀ i f, ZFSet.pair i f ∈ family ↔ i ∈ I ∧ f = batchTemplateGraph I P Qs rs As Es i) ∧
      ∀ (i : {i : ZFSet.{u} // i ∈ I}) f, ZFSet.pair i.val f ∈ family →
        MeetEmbeddingCode (d.space i) d.batchCarrier (d.rel i) d.batchOrder
          (d.meet i) d.batchMeetGraph f := by
  obtain ⟨hL, hr, hm, _, _, _⟩ := M.batchAttachment_ground_codes
    pairing unions powers separation d hP hrP hI hQs hrs hμs hAs hEs hFs
  obtain ⟨member, function, entries⟩ := M.batchEmbeddingFamily_spec
    pairing unions powers separation hI hP hQs hrs hAs hEs
  refine ⟨hL, hr, hm, d.batch_meetOrder, M.batchEmbeddingFamily I P Qs rs As Es,
    member, function, entries, ?_⟩
  intro i f entry
  have eq := ((entries i.val f).1 entry).2
  exact eq.symm ▸ d.batch_template_embedding_code i

end TransitiveGround

end

namespace TransitiveGround

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

noncomputable def definable_liftedCompressionFamily
    (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) :
    GroundDefinableFunction M (fun env : Fin 13 → ZFSet.{u} =>
      M.groundLiftedCompressionFamily (env 0) (env 1) (env 2) (env 3) (env 4) (env 5)
        (env 6) (env 7) (env 8) (env 9) (env 10) (env 11) (env 12)) := by
  let doubleUnion : GroundDefinableFunction M
      (fun env : Fin 1 → ZFSet.{u} => ZFSet.sUnion (ZFSet.sUnion (env 0))) :=
    (M.definable_sUnion unions).comp (fun _ => M.definable_sUnion unions)
  let bounds : Fin 2 → (Fin 13 → ZFSet.{u}) → ZFSet.{u} :=
    ![(fun env => ZFSet.sUnion (ZFSet.sUnion (env 7))),
      (fun env => ZFSet.sUnion (ZFSet.sUnion (env 9)))]
  have definedBounds : ∀ j, GroundDefinableFunction M (bounds j) := by
    intro j
    exact Fin.cases (doubleUnion.reindex (fun _ => 7))
      (Fin.cases (doubleUnion.reindex (fun _ => 9)) (fun k => Fin.elim0 k)) j
  refine GroundDefinableFunction.withAuxFamily definedBounds
    (liftedCompressionFamilyFormula 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 1) ?_ ?_
  · intro env members
    exact (M.groundLiftedCompressionFamily_spec pairing unions powers separation
      (members 0) (members 1) (members 2) (members 3) (members 4) (members 5) (members 6)
      (members 7) (members 8) (members 9) (members 10) (members 11) (members 12)).1
  · intro env members z hz
    exact M.realize_liftedCompressionFamilyFormula pairing unions powers separation
      2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 1
      (extend (ZFSet.sUnion (ZFSet.sUnion (env 7)))
        (extend (ZFSet.sUnion (ZFSet.sUnion (env 9))) (extend z env)))
      (Fin.cases (M.union_mem unions (M.union_mem unions (members 7)))
        (Fin.cases (M.union_mem unions (M.union_mem unions (members 9)))
          (Fin.cases hz members))) rfl rfl

end TransitiveGround

namespace TransitiveGround
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)
include pairing unions powers separation

noncomputable def definable_indexedDomain : GroundDefinableFunction M
    (fun env : Fin 2 → ZFSet.{u} => indexedAttachmentDomain (env 0) (env 1)) := by
  let aux := (M.definable_doubleUnion unions).reindex (fun _ : Fin 1 => (1 : Fin 2))
  refine aux.withAux (indexedDomainSetFormula 1 2 3 0) ?_ ?_
  · intro env members
    exact M.indexedAttachmentDomain_mem pairing unions powers separation (members 0) (members 1)
  · intro env members z hz
    exact M.realize_indexedDomainSetFormula pairing unions powers separation 1 2 3 0
      _ (Fin.cases (aux.closed env members) (Fin.cases hz members)) rfl

noncomputable def definable_batchTemplate : GroundDefinableFunction M
    (fun env : Fin 6 → ZFSet.{u} => batchAttachmentTemplateGraph
      (env 0) (env 1) (env 2) (env 3) (env 4) (env 5)) := by
  let domain := (M.definable_indexedDomain pairing unions powers separation).reindex
    (Fin.cases (0 : Fin 6) (Fin.cases 2 Fin.elim0))
  let fresh := (M.definable_indexedFresh pairing unions powers separation).reindex
    (Fin.cases (0 : Fin 6) (Fin.cases 2 (Fin.cases 3 (Fin.cases 4 Fin.elim0))))
  let carrierValues : Fin 2 → (Fin 6 → ZFSet.{u}) → ZFSet.{u} :=
    Fin.cases (fun env => env 1) (Fin.cases
      (fun env => indexedAttachmentFresh (env 0) (env 2) (env 3) (env 4)) Fin.elim0)
  let carrier := (M.definable_taggedExtension pairing unions powers separation).comp
    (g := carrierValues)
    (Fin.cases (GroundDefinableFunction.projection M (1 : Fin 6)) (Fin.cases fresh (fun j => Fin.elim0 j)))
  let points := ((M.definable_sUnion unions).comp
    (fun _ : Fin 1 => M.definable_doubleUnion unions)).reindex (fun _ : Fin 1 => (2 : Fin 6))
  let bases := (M.definable_doubleUnion unions).reindex (fun _ : Fin 1 => (5 : Fin 6))
  let values : Fin 5 → (Fin 6 → ZFSet.{u}) → ZFSet.{u} := Fin.cases
    (fun env => indexedAttachmentDomain (env 0) (env 2)) (Fin.cases
    (fun env => indexedAttachmentFresh (env 0) (env 2) (env 3) (env 4)) (Fin.cases
    (fun env => taggedExtension (env 1) (indexedAttachmentFresh (env 0) (env 2) (env 3) (env 4))) (Fin.cases
    (fun env => familyPointBound (env 2))
      (Fin.cases (fun env => ZFSet.sUnion (ZFSet.sUnion (env 5))) Fin.elim0))))
  let aux : ∀ j, GroundDefinableFunction M (values j) :=
    Fin.cases domain (Fin.cases fresh (Fin.cases carrier (Fin.cases points (Fin.cases bases (fun j => Fin.elim0 j)))))
  refine GroundDefinableFunction.withAuxFamily aux (batchTemplateSetFormula 5 0 2 7 6 3 11 4 1) ?_ ?_
  · intro env members
    exact M.batchAttachmentTemplateGraph_mem pairing unions powers separation
      (members 0) (members 1) (members 2) (members 3) (members 4) (members 5)
  · intro env members z hz
    exact M.realize_batchTemplateSetFormula pairing unions powers separation
      5 0 2 7 6 8 9 10 11 3 4 1 _
      (extendMany_members 5 _ _ (fun j => (aux j).closed env members) (Fin.cases hz members))
      rfl rfl rfl rfl rfl

noncomputable def definable_indexedSections : GroundDefinableFunction M
    (fun env : Fin 4 → ZFSet.{u} => M.indexedRelationSections (env 0) (env 1) (env 2) (env 3)) where
  formula := sectionFamilyFormula 0 1 2 3 4
  closed := fun _ members => (M.indexedRelationSections_spec pairing unions powers separation
    (members 0) (members 1) (members 2) (members 3)).1
  correct := fun env members z hz => M.realize_sectionFamilyFormula pairing 0 1 2 3 4
    (extend z env) (Fin.cases hz members)

noncomputable def definable_batchEmbeddingFamily : GroundDefinableFunction M
    (fun env : Fin 6 → ZFSet.{u} => M.batchEmbeddingFamily
      (env 0) (env 1) (env 2) (env 3) (env 4) (env 5)) := by
  let fresh := (M.definable_indexedFresh pairing unions powers separation).reindex
    (Fin.cases (0 : Fin 6) (Fin.cases 2 (Fin.cases 3 (Fin.cases 4 Fin.elim0))))
  let carrierValues : Fin 2 → (Fin 6 → ZFSet.{u}) → ZFSet.{u} :=
    Fin.cases (fun env => env 1) (Fin.cases
      (fun env => indexedAttachmentFresh (env 0) (env 2) (env 3) (env 4)) Fin.elim0)
  let carrier := (M.definable_taggedExtension pairing unions powers separation).comp
    (g := carrierValues)
    (Fin.cases (GroundDefinableFunction.projection M (1 : Fin 6)) (Fin.cases fresh (fun j => Fin.elim0 j)))
  let points := ((M.definable_sUnion unions).comp
    (fun _ : Fin 1 => M.definable_doubleUnion unions)).reindex (fun _ : Fin 1 => (2 : Fin 6))
  let values : Fin 4 → (Fin 6 → ZFSet.{u}) → ZFSet.{u} :=
    Fin.cases (fun env => env 0) (Fin.cases (fun env => familyPointBound (env 2))
      (Fin.cases (fun env => taggedExtension (env 1)
        (indexedAttachmentFresh (env 0) (env 2) (env 3) (env 4)))
        (Fin.cases (fun env => batchAttachmentTemplateGraph
          (env 0) (env 1) (env 2) (env 3) (env 4) (env 5)) Fin.elim0)))
  exact (M.definable_indexedSections pairing unions powers separation).comp (g := values)
    (Fin.cases (GroundDefinableFunction.projection M (0 : Fin 6))
      (Fin.cases points (Fin.cases carrier
        (Fin.cases (M.definable_batchTemplate pairing unions powers separation) (fun j => Fin.elim0 j)))))

noncomputable def batchEmbeddingFamilyFormula {n}
    (output I P Qs rs As Es : Fin n) : SetFormula n :=
  SetFormula.reindex
    (Fin.cases output (Fin.cases I (Fin.cases P (Fin.cases Qs
      (Fin.cases rs (Fin.cases As (Fin.cases Es Fin.elim0)))))))
    (M.definable_batchEmbeddingFamily pairing unions powers separation).formula

theorem realize_batchEmbeddingFamilyFormula {n}
    (output I P Qs rs As Es : Fin n) (env : Fin n → ZFSet.{u})
    (members : ∀ i, env i ∈ M.sets) :
    Realize M.sets (M.batchEmbeddingFamilyFormula pairing unions powers separation output I P Qs rs As Es) env ↔
      env output = M.batchEmbeddingFamily (env I) (env P) (env Qs) (env rs) (env As) (env Es) := by
  let slots : Fin 6 → Fin n := Fin.cases I (Fin.cases P (Fin.cases Qs
    (Fin.cases rs (Fin.cases As (Fin.cases Es Fin.elim0)))))
  unfold batchEmbeddingFamilyFormula
  rw [realize_reindex]
  change Realize M.sets (M.definable_batchEmbeddingFamily pairing unions powers separation).formula
    (fun j => env (extend output slots j)) ↔ _
  rw [map_extend]
  exact (M.definable_batchEmbeddingFamily pairing unions powers separation).correct
    (fun j => env (slots j)) (fun j => members (slots j)) (env output) (members output)

end TransitiveGround

end PartitionPilot.Forcing

end OAI