import OAI.SetTheory.PartitionPrinciple.Geometry.GroundConstantBatchLayers
import OAI.SetTheory.PartitionPrinciple.Transfinite.CompressionPrefixCoinitiality

namespace OAI

namespace PartitionPilot.Forcing

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

theorem groundEligibleBatchLayerWitness
    (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 G r μ A Labels m inv one HQs Hrs Hμs HTime T birth stamp τ N : 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)
    (group : GroupCode G m inv one) (action : PosetActionCode G P m one r A)
    (meet : MeetOrderCode P r μ)
    (historySpaces : FunctionGraphOn HTime HQs)
    (historyOrders : FunctionGraphOn HTime Hrs)
    (historyMeets : FunctionGraphOn HTime Hμs)
    (born : ZFSet.IsFunc P T birth)
    (earlier : ∀ x t, ZFSet.pair x t ∈ birth → t ∈ stamp)
    (hStamp : stamp ∈ M.sets) (before : τ ∈ stamp)
    (source : ZFSet.pair τ P ∈ HQs ∧ ZFSet.pair τ r ∈ Hrs ∧ ZFSet.pair τ μ ∈ Hμs) :
    let d := M.groundEligibleTaskBatchInputs (Labels := Labels) group action meet
    d.constantBatchLayerWitness M τ ∈ M.sets ∧
      GrowthLayerWitnessCode HQs Hrs Hμs d.batchCarrier d.batchOrder d.batchMeetGraph
        (d.batchBirth birth stamp) stamp N (d.constantBatchLayerWitness M τ) := by
  let d := M.groundEligibleTaskBatchInputs (Labels := Labels) group action meet
  have fields := M.groundEligibleTaskFields pairing unions powers separation hP hG hr hμ hA hLabels meet
  apply d.constantBatchLayerWitness_spec pairing unions powers separation hP fields.1 fields.2.1
    fields.2.2.1 (fields.2.2.2.2 0).1 (fields.2.2.2.2 2).1
    historySpaces historyOrders historyMeets born earlier hStamp before ?_ source
  intro i
  exact ⟨((pair_mem_constantFamilyGraph _ _ _ _).1 (d.space_entry i)).2,
    ((pair_mem_constantFamilyGraph _ _ _ _).1 (d.rel_entry i)).2,
    ((pair_mem_constantFamilyGraph _ _ _ _).1 (d.meet_entry i)).2⟩

end TransitiveGround

section
open SetRealization
universe u

theorem batchFamilyPointBound_rank_le (Qs : ZFSet.{u}) :
    ZFSet.rank (familyPointBound Qs) ≤ ZFSet.rank Qs :=
  (ZFSet.rank_sUnion_le _).trans ((ZFSet.rank_sUnion_le _).trans (ZFSet.rank_sUnion_le _))

namespace TransitiveGround
variable (M : TransitiveGround.{u})
variable {o : Ordinal.{u}} (limit : Order.IsSuccLimit o)
include limit

theorem batchTemplateFamilyBound_rank_lt {I P Qs : ZFSet.{u}} (rs As : ZFSet.{u})
    (points : ZFSet.rank P < o) (indices : ZFSet.rank I < o)
    (spaces : ZFSet.rank Qs < o) :
    ZFSet.rank (M.batchTemplateFamilyBound I P Qs rs As) < o := by
  have source := (batchFamilyPointBound_rank_le Qs).trans_lt spaces
  have fresh := (ZFSet.rank_mono (fun z hz => indexedAttachmentDomain_subset I Qs
    (indexedAttachmentFresh_subset I Qs rs As hz))).trans_lt (rank_product_lt limit indices source)
  exact M.groundRelations_rank_lt limit source (rank_taggedExtension_lt limit points fresh)

theorem batchTemplateFamily_rank_lt {I P Qs : ZFSet.{u}} (rs As Es : ZFSet.{u})
    (points : ZFSet.rank P < o) (indices : ZFSet.rank I < o)
    (spaces : ZFSet.rank Qs < o) :
    ZFSet.rank (M.batchTemplateFamily I P Qs rs As Es) < o := by
  have subset : M.batchTemplateFamily I P Qs rs As Es ⊆
      ZFSet.prod I (M.batchTemplateFamilyBound I P Qs rs As) := by
    intro z hz
    unfold batchTemplateFamily indexedRelationSections at hz
    exact (ZFSet.mem_sep.1 hz).1
  exact (ZFSet.rank_mono subset).trans_lt (rank_product_lt limit indices
    (M.batchTemplateFamilyBound_rank_lt limit rs As points indices spaces))

end TransitiveGround

namespace AttachmentBatchInputs
variable {M : TransitiveGround.{u}}
variable {P r μ I Qs rs μs As Es Fs Ss : ZFSet.{u}}
variable (d : AttachmentBatchInputs P r μ I Qs rs μs As Es Fs Ss)
variable {o : Ordinal.{u}} (limit : Order.IsSuccLimit o)
include limit

theorem batchIncomingFiber_rank_lt
    (points : ZFSet.rank P < o) (indices : ZFSet.rank I < o)
    (spaces : ZFSet.rank Qs < o) : ZFSet.rank d.batchIncomingFiber < o := by
  have fresh := (ZFSet.rank_mono (fun z hz => indexedAttachmentDomain_subset I Qs
    (indexedAttachmentFresh_subset I Qs rs As hz))).trans_lt
      (rank_product_lt limit indices ((batchFamilyPointBound_rank_le Qs).trans_lt spaces))
  exact rank_product_lt limit (rank_singleton_lt limit points) fresh

theorem constantBatchLayerWitness_rank_lt (M : TransitiveGround.{u}) {τ : ZFSet.{u}}
    (points : ZFSet.rank P < o) (indices : ZFSet.rank I < o)
    (spaces : ZFSet.rank Qs < o) (time : ZFSet.rank τ < o) :
    ZFSet.rank (d.constantBatchLayerWitness M τ) < o := by
  have fiber := d.batchIncomingFiber_rank_lt limit points indices spaces
  exact separatedLayerWitness_rank_lt limit indices
    (rank_constantFamilyGraph_lt limit indices time)
    (M.batchTemplateFamily_rank_lt limit rs As Es points indices spaces)
    (M.batchTemplateFamilyBound_rank_lt limit rs As points indices spaces)
    (rank_functionGraph_lt limit d.batchIncomingComponents_function fiber indices) fiber

end AttachmentBatchInputs

end

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

theorem groundEligibleBatchLayerWitness_rank_lt
    {P G r μ A Labels m inv one τ : ZFSet.{u}}
    (group : GroupCode G m inv one) (action : PosetActionCode G P m one r A)
    (meet : MeetOrderCode P r μ) {o : Ordinal.{u}} (limit : Order.IsSuccLimit o)
    (points : ZFSet.rank P < o) (labels : ZFSet.rank Labels < o)
    (time : ZFSet.rank τ < o) :
    ZFSet.rank ((M.groundEligibleTaskBatchInputs (Labels := Labels) group action meet).constantBatchLayerWitness M τ) < o := by
  have tasks := M.groundEligibleTasks_rank_lt limit G r μ A points labels
  exact (M.groundEligibleTaskBatchInputs (Labels := Labels) group action meet).constantBatchLayerWitness_rank_lt
    limit M points tasks (rank_constantFamilyGraph_lt limit tasks points) time

theorem groundEligibleBatchLayerWitness_ranked
    (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 G r μ A Labels m inv one HQs Hrs Hμs HTime T birth stamp τ N : 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)
    (group : GroupCode G m inv one) (action : PosetActionCode G P m one r A)
    (meet : MeetOrderCode P r μ)
    (historySpaces : FunctionGraphOn HTime HQs)
    (historyOrders : FunctionGraphOn HTime Hrs)
    (historyMeets : FunctionGraphOn HTime Hμs)
    (born : ZFSet.IsFunc P T birth)
    (earlier : ∀ x t, ZFSet.pair x t ∈ birth → t ∈ stamp)
    (hStamp : stamp ∈ M.sets) (before : τ ∈ stamp)
    (source : ZFSet.pair τ P ∈ HQs ∧ ZFSet.pair τ r ∈ Hrs ∧ ZFSet.pair τ μ ∈ Hμs)
    {o : Ordinal.{u}} (limit : Order.IsSuccLimit o) (points : ZFSet.rank P < o)
    (labels : ZFSet.rank Labels < o) (time : ZFSet.rank τ < o) :
    let d := M.groundEligibleTaskBatchInputs (Labels := Labels) group action meet
    d.constantBatchLayerWitness M τ ∈ M.sets ∧
      ZFSet.rank (d.constantBatchLayerWitness M τ) < o ∧
      GrowthLayerWitnessCode HQs Hrs Hμs d.batchCarrier d.batchOrder d.batchMeetGraph
        (d.batchBirth birth stamp) stamp N (d.constantBatchLayerWitness M τ) := by
  have code := M.groundEligibleBatchLayerWitness pairing unions powers separation hP hG hr hμ hA hLabels
    group action meet historySpaces historyOrders historyMeets born earlier hStamp before source (N := N)
  exact ⟨code.1, M.groundEligibleBatchLayerWitness_rank_lt group action meet limit points labels time, code.2⟩

end TransitiveGround

namespace GroundCompressionState
open SetFormula SetRealization
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 (data : GroundCompressionUnionData M state.data I Sources Reps G m one T)
variable {base old : ZFSet.{u}}
variable (births : GroundCompressionBirthData M state.data I Sources Reps G m one T data base old)

theorem exists_canonicalIncomingRankedWitness
    (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)
    (hI : I ∈ M.sets) (hSources : Sources ∈ M.sets) (hReps : Reps ∈ M.sets)
    (hG : G ∈ M.sets) (hT : T ∈ M.sets)
    (constant : RecursiveTemplateConstancy P0 r0 μ0 state.data)
    {HQs Hrs Hμs HTime N : ZFSet.{u}}
    (historySpaces : FunctionGraphOn HTime HQs)
    (historyOrders : FunctionGraphOn HTime Hrs)
    (historyMeets : FunctionGraphOn HTime Hμs)
    (source : ZFSet.pair base P0 ∈ HQs ∧ ZFSet.pair base r0 ∈ Hrs ∧ ZFSet.pair base μ0 ∈ Hμs)
    {o : Ordinal.{u}} (limit : Order.IsSuccLimit o)
    (points : ZFSet.rank state.data.D < o) (indices : ZFSet.rank state.data.J < o)
    (templates : ZFSet.rank P0 < o) (tasks : ZFSet.rank I < o)
    (time : ZFSet.rank base < o) (n : Nat) :
    ∃ z ∈ M.sets, ZFSet.rank z < o ∧ GrowthLayerWitnessCode HQs Hrs Hμs
      (state.data.iterate M I Sources Reps G T (n + 1)).D
      (state.data.iterate M I Sources Reps G T (n + 1)).rD
      (state.data.iterate M I Sources Reps G T (n + 1)).μD
      (graphRestriction (state.data.iterate M I Sources Reps G T (n + 1)).D births.birth)
      (compressionStamp base n) N z := by
  let current := state.iterate pairing unions powers separation hI hSources hReps hG hT n
  have equal : current.data = state.data.iterate M I Sources Reps G T n :=
    state.iterate_data pairing unions powers separation hI hSources hReps hG hT n
  have currentConstant : RecursiveTemplateConstancy P0 r0 μ0 current.data := by
    simpa only [equal] using constant.iterate M I Sources Reps G T n
  have finite : ZFSet.IsFunc current.data.D births.limit
      (graphRestriction (state.data.iterate M I Sources Reps G T n).D births.birth) := by
    simpa only [equal] using state.canonical_birth_function data pairing unions powers separation
      hI hSources hReps hG hT births.extension births.initial_function births.times n
  have earlier : ∀ x t, ZFSet.pair x t ∈
      graphRestriction (state.data.iterate M I Sources Reps G T n).D births.birth →
      t ∈ compressionStamp base n := fun _ _ entry =>
    state.canonical_birth_before_stamp pairing unions powers separation hI hSources hReps hG hT
      births.extension births.initial_bound n entry
  have result := current.batch.constantBatchLayerWitness_spec pairing unions powers separation
    current.ground.carrier current.ground.indices current.ground.spaces current.ground.relations
    current.ground.anchors current.ground.embeddings historySpaces historyOrders historyMeets finite earlier
    (M.transitive births.limit_ground (births.times.stamp_mem_limit n)) (compressionStamp_base_mem base n)
    (fun i => ⟨((currentConstant.space_entry_iff _ _).1 (current.batch.space_entry i)).2,
      ((currentConstant.relation_entry_iff _ _).1 (current.batch.rel_entry i)).2,
      ((currentConstant.meet_entry_iff _ _).1 (current.batch.meet_entry i)).2⟩) source (N := N)
  have finiteRanks := constant.iterate_carrier_ranks M I Sources Reps G T limit
    points indices templates tasks n
  have pointRank : ZFSet.rank current.data.D < o := by simpa only [equal] using finiteRanks.1
  have indexRank : ZFSet.rank current.data.J < o := by simpa only [equal] using finiteRanks.2
  have spaceRank : ZFSet.rank current.data.Qs < o := by
    rw [currentConstant.spaces]
    exact rank_constantFamilyGraph_lt limit indexRank templates
  have witnessRank := current.batch.constantBatchLayerWitness_rank_lt limit M
    pointRank indexRank spaceRank time
  refine ⟨current.batch.constantBatchLayerWitness M base, result.1, witnessRank, ?_⟩
  have code := result.2
  change GrowthLayerWitnessCode HQs Hrs Hμs current.data.currentCarrier
    current.data.currentOrder current.data.currentMeet
    (taggedBirth current.data.D current.data.fresh
      (graphRestriction (state.data.iterate M I Sources Reps G T n).D births.birth)
      (compressionStamp base n)) (compressionStamp base n) N _ at code
  rw [state.canonical_birth_step pairing unions powers separation hI hSources hReps hG hT
    births.extension births.initial_function n]
  simpa only [equal, RecursiveStateData.iterate_succ, RecursiveStateData.successor] using code

end GroundCompressionState

end PartitionPilot.Forcing

end OAI