import OAI.SetTheory.PartitionPrinciple.Forcing.InitialAction

namespace OAI

section

namespace PartitionPilot.Compression.RecursiveMaps

open Attachment

universe u

structure CompressionStage {A G Task Label : Type u} {P : MeetOrder A}
    (f : TaskSystem P G Task Label) where
  Old : Type u
  Components : Type u
  oldOrder : MeetOrder Old
  batch : Templates.{u,u,u} oldOrder Components
  original : MeetEmbedding P oldOrder
  inputs : Inputs batch Task
  source_original : ∀ i, inputs.source i = original.toFun (f.datum i).source
  top : ∀ x, oldOrder.le x (original.toFun f.top)
  symmetry : G → TaskSymmetry inputs
  perm_eq : ∀ g i, (symmetry g).perm i = f.perm g i
  representatives : ∀ i x, (symmetry (f.representative i)).current.toFun x =
    (inputs.representative i).toFun x
  action_one : ∀ x, (symmetry f.group.one).current.toFun x = x
  action_mul : ∀ g h x, (symmetry (f.group.mul g h)).current.toFun x =
    (symmetry g).current.toFun ((symmetry h).current.toFun x)
  action_original : ∀ g x, (symmetry g).current.toFun (.inl (original.toFun x)) =
    .inl (original.toFun ((f.action g).toFun x))
  agreement : ∀ g h v,
    (∀ x, P.le x v → (f.action g).toFun x = (f.action h).toFun x) →
    ∀ x, batch.extension.le x (.inl (original.toFun v)) →
      (symmetry g).current.toFun x = (symmetry h).current.toFun x
  negative : ∀ i v, ¬ (f.datum i).filter.mem v →
    batch.extension.le
      (batch.extension.meet ((inputs.previous i).toFun (original.toFun f.top))
        (.inl (original.toFun v)))
      ((inputs.previous i).toFun (inputs.source i))

namespace CompressionStage

variable {A G Task Label : Type u} {P : MeetOrder A} {f : TaskSystem P G Task Label}
    (s : CompressionStage f)

theorem compatible (g : G) (i : Task) (x : s.Old ⊕ s.batch.Fresh)
    (hx : s.batch.extension.le x (.inl (s.inputs.source i))) :
    (s.symmetry g).current.toFun ((s.inputs.representative i).toFun x) =
      (s.inputs.representative ((s.symmetry g).perm i)).toFun x := by
  have ground : ∀ y, P.le y (f.datum i).source →
      (f.action (f.group.mul g (f.representative i))).toFun y =
        (f.action (f.representative (f.perm g i))).toFun y := by
    intro y hy
    rw [f.action_mul]
    exact f.ground_compatible g i y hy
  rw [s.source_original] at hx
  have current := s.agreement (f.group.mul g (f.representative i))
    (f.representative (f.perm g i)) (f.datum i).source ground x hx
  rw [s.action_mul, s.representatives, s.representatives] at current
  rw [s.perm_eq]
  exact current

noncomputable def nextInputs : Inputs s.inputs.nextBatch Task :=
  s.inputs.nextInputs (fun i => s.symmetry (f.representative i)) s.representatives

noncomputable def nextAction (g : G) : TaskSymmetry s.nextInputs :=
  s.inputs.nextSymmetry (fun i => s.symmetry (f.representative i)) s.representatives
    (s.symmetry g) (s.compatible g)

theorem next_action_one (x : (s.Old ⊕ s.batch.Fresh) ⊕ s.inputs.nextBatch.Fresh) :
    (s.nextAction f.group.one).current.toFun x = x := by
  cases x with
  | inl x => exact congrArg Sum.inl (s.action_one x)
  | inr x =>
    rcases x with ⟨⟨i, ⟨h, eligible⟩⟩, ⟨y, outside⟩⟩
    apply congrArg Sum.inr
    exact TaskSymmetry.fresh_task_eq ((s.perm_eq f.group.one i).trans (f.perm_one i))

theorem next_action_mul (g h : G)
    (x : (s.Old ⊕ s.batch.Fresh) ⊕ s.inputs.nextBatch.Fresh) :
    (s.nextAction (f.group.mul g h)).current.toFun x =
      (s.nextAction g).current.toFun ((s.nextAction h).current.toFun x) := by
  cases x with
  | inl x => exact congrArg Sum.inl (s.action_mul g h x)
  | inr x =>
    rcases x with ⟨⟨i, ⟨k, eligible⟩⟩, ⟨y, outside⟩⟩
    apply congrArg Sum.inr
    apply TaskSymmetry.fresh_task_eq
    change (s.symmetry (f.group.mul g h)).perm i = (s.symmetry g).perm ((s.symmetry h).perm i)
    rw [s.perm_eq, s.perm_eq, s.perm_eq, f.perm_mul]

theorem next_action_original (g : G) (x : A) :
    (s.nextAction g).current.toFun (.inl (.inl (s.original.toFun x))) =
      .inl (.inl (s.original.toFun ((f.action g).toFun x))) :=
  congrArg Sum.inl (s.action_original g x)

theorem next_agreement (g h : G) (v : A)
    (agree : ∀ x, P.le x v → (f.action g).toFun x = (f.action h).toFun x)
    (x : (s.Old ⊕ s.batch.Fresh) ⊕ s.inputs.nextBatch.Fresh)
    (below : s.inputs.nextBatch.extension.le x (.inl (.inl (s.original.toFun v)))) :
    (s.nextAction g).current.toFun x = (s.nextAction h).current.toFun x := by
  apply TaskDatum.successor_agreement (s.symmetry g) (s.symmetry h) s.original
    f.datum f.faithful f.geometry (f.action g) (f.action h)
    (fun i => (congrArg f.datum (s.perm_eq g i)).trans (f.transport g i))
    (fun i => (congrArg f.datum (s.perm_eq h i)).trans (f.transport h i))
    (s.original.toFun f.top) s.top v (fun i => s.negative i v)
    agree (s.agreement g h v agree) x below

theorem next_negative (i : Task) (v : A) (negative : ¬ (f.datum i).filter.mem v) :
    s.inputs.nextBatch.extension.le
      (s.inputs.nextBatch.extension.meet
        ((s.nextInputs.previous i).toFun (.inl (s.original.toFun f.top)))
        (.inl (.inl (s.original.toFun v))))
      ((s.nextInputs.previous i).toFun (s.nextInputs.source i)) := by
  have h := (s.inputs.nextBatch.oldEmbedding.le_iff _ _).mpr (s.negative i v negative)
  have hm := s.inputs.nextBatch.oldEmbedding.map_meet
    ((s.inputs.previous i).toFun (s.original.toFun f.top)) (.inl (s.original.toFun v))
  rw [hm] at h
  exact h

noncomputable def next : CompressionStage f where
  Old := s.Old ⊕ s.batch.Fresh
  Components := s.inputs.Labels
  oldOrder := s.batch.extension
  batch := s.inputs.nextBatch
  original := compose s.original s.batch.oldEmbedding
  inputs := s.nextInputs
  source_original i := congrArg Sum.inl (s.source_original i)
  top := s.batch.greatest_preserved (s.original.toFun f.top) s.top
  symmetry := s.nextAction
  perm_eq := s.perm_eq
  representatives _ _ := rfl
  action_one := s.next_action_one
  action_mul := s.next_action_mul
  action_original := s.next_action_original
  agreement := s.next_agreement
  negative := s.next_negative

end CompressionStage

namespace TaskSystem

variable {A G Task Label : Type u} {P : MeetOrder A} (f : TaskSystem P G Task Label)

noncomputable def firstStage : CompressionStage f where
  Old := A
  Components := Task
  oldOrder := P
  batch := f.initial.batch
  original := (identityIso P).toMeetEmbedding
  inputs := f.initialInputs
  source_original _ := rfl
  top := f.greatest
  symmetry := f.initialSymmetry
  perm_eq _ _ := rfl
  representatives _ _ := rfl
  action_one := f.initialIso_one
  action_mul := f.initialIso_mul
  action_original := f.initialIso_old
  agreement := f.initial_agreement
  negative := f.initial_negative

noncomputable def stages : Nat → CompressionStage f
  | 0 => f.firstStage
  | n + 1 => (stages n).next

theorem stages_agreement (n : Nat) (g h : G) (v : A)
    (agree : ∀ x, P.le x v → (f.action g).toFun x = (f.action h).toFun x)
    (x : (f.stages n).Old ⊕ (f.stages n).batch.Fresh)
    (below : (f.stages n).batch.extension.le x (.inl ((f.stages n).original.toFun v))) :
    ((f.stages n).symmetry g).current.toFun x =
      ((f.stages n).symmetry h).current.toFun x :=
  (f.stages n).agreement g h v agree x below

end TaskSystem
end PartitionPilot.Compression.RecursiveMaps



namespace PartitionPilot.Compression.RecursiveMaps.TaskSystem

open Attachment

universe u

variable {A G Task Label : Type u} {P : MeetOrder A} (f : TaskSystem P G Task Label)

def Point (n : Nat) : Type u := (f.stages n).Old

noncomputable def order (n : Nat) : MeetOrder (f.Point n) := (f.stages n).oldOrder

noncomputable def origin (n : Nat) : MeetEmbedding P (f.order n) := (f.stages n).original

noncomputable def step (n : Nat) : MeetEmbedding (f.order n) (f.order (n + 1)) :=
  (f.stages n).batch.oldEmbedding

noncomputable def compression (n : Nat) (i : Task) : MeetEmbedding (f.order n) (f.order (n + 1)) :=
  (f.stages n).inputs.previous i

noncomputable def stageAction : (n : Nat) → G → MeetIso (f.order n) (f.order n)
  | 0, g => f.action g
  | n + 1, g => ((f.stages n).symmetry g).current

theorem origins_coherent (n : Nat) (x : A) :
    (f.step n).toFun ((f.origin n).toFun x) = (f.origin (n + 1)).toFun x := rfl

theorem maps_coherent (n : Nat) (i : Task) (x : f.Point n) :
    (f.step (n + 1)).toFun ((f.compression n i).toFun x) =
      (f.compression (n + 1) i).toFun ((f.step n).toFun x) := rfl

theorem actions_coherent (n : Nat) (g : G) (x : f.Point n) :
    (f.step n).toFun ((f.stageAction n g).toFun x) =
      (f.stageAction (n + 1) g).toFun ((f.step n).toFun x) := by
  cases n <;> rfl

theorem stage_bottom (n : Nat) (zero : A) (bottom : ∀ x, P.le zero x) :
    ∀ x : f.Point n, (f.order n).le ((f.origin n).toFun zero) x := by
  induction n with
  | zero => exact bottom
  | succ n ih => exact (f.stages n).batch.least_preserved ((f.origin n).toFun zero) ih

theorem stageAction_one (n : Nat) (x : f.Point n) :
    (f.stageAction n f.group.one).toFun x = x := by
  cases n with
  | zero => exact f.action_one x
  | succ n => exact (f.stages n).action_one x

theorem stageAction_mul (n : Nat) (g h : G) (x : f.Point n) :
    (f.stageAction n (f.group.mul g h)).toFun x =
      (f.stageAction n g).toFun ((f.stageAction n h).toFun x) := by
  cases n with
  | zero => exact f.action_mul g h x
  | succ n => exact (f.stages n).action_mul g h x

theorem stageAction_original (n : Nat) (g : G) (x : A) :
    (f.stageAction n g).toFun ((f.origin n).toFun x) =
      (f.origin n).toFun ((f.action g).toFun x) := by
  cases n with
  | zero => rfl
  | succ n => exact (f.stages n).action_original g x

theorem stage_equivariant (n : Nat) (g : G) (i : Task) (x : f.Point n) :
    (f.stageAction (n + 1) g).toFun ((f.compression n i).toFun x) =
      (f.compression n (f.perm g i)).toFun x := by
  have h := ((f.stages n).symmetry g).intertwine i x
  rw [(f.stages n).perm_eq] at h
  exact h

theorem stage_agreement (n : Nat) (g h : G) (v : A)
    (agree : ∀ x, P.le x v → (f.action g).toFun x = (f.action h).toFun x)
    (x : f.Point n) (below : (f.order n).le x ((f.origin n).toFun v)) :
    (f.stageAction n g).toFun x = (f.stageAction n h).toFun x := by
  cases n with
  | zero => exact agree x below
  | succ n => exact (f.stages n).agreement g h v agree x below

theorem stage_base_agreement (n : Nat) (i : Task) (x : f.Point n)
    (below : (f.order n).le x ((f.origin n).toFun (f.datum i).source)) :
    (f.compression n i).toFun x =
      (f.step n).toFun ((f.stageAction n (f.representative i)).toFun x) := by
  have hx : (f.stages n).oldOrder.le x ((f.stages n).inputs.source i) := by
    rw [(f.stages n).source_original]
    exact below
  exact ((f.stages n).inputs.agree i x hx).trans
    (((f.stages n).representatives i (.inl x)).symm.trans
      (f.actions_coherent n (f.representative i) x).symm)

theorem maps_base (n : Nat) (i : Task) :
    (f.compression n i).toFun ((f.origin n).toFun (f.datum i).source) =
      (f.origin (n + 1)).toFun (f.datum i).target := by
  rw [f.stage_base_agreement n i _ ((f.order n).refl _), f.stageAction_original,
    f.representative_target, f.origins_coherent]

noncomputable def cap (n : Nat) (i : Task) : f.Point (n + 1) :=
  (f.compression n i).toFun ((f.origin n).toFun f.top)

theorem caps_coherent (n : Nat) (i : Task) :
    (f.step (n + 1)).toFun (f.cap n i) = f.cap (n + 1) i :=
  f.maps_coherent n i ((f.origin n).toFun f.top)

theorem range_below_cap (n : Nat) (i : Task) (x : f.Point n) :
    (f.order (n + 1)).le ((f.compression n i).toFun x) (f.cap n i) :=
  ((f.compression n i).le_iff _ _).mpr ((f.stages n).top x)

theorem cap_separation (n : Nat) (i j : Task) (different : i ≠ j) :
    (f.order (n + 1)).le (f.cap n i) ((f.origin (n + 1)).toFun (f.datum j).target) ∨
    (f.order (n + 1)).le (f.cap n j) ((f.origin (n + 1)).toFun (f.datum i).target) ∨
    (f.order (n + 1)).meet (f.cap n i) (f.cap n j) =
      (f.order (n + 1)).meet ((f.origin (n + 1)).toFun (f.datum i).target)
        ((f.origin (n + 1)).toFun (f.datum j).target) := by
  induction n with
  | zero =>
    have h := f.initial.copy_cap_separation f.top f.greatest f.source_proper i j different
    have bi : f.initial.batch.base i = (f.datum i).target := f.representative_target i
    have bj : f.initial.batch.base j = (f.datum j).target := f.representative_target j
    rw [bi, bj] at h
    exact h
  | succ n ih =>
    rcases ih with h | h | h
    · have hn := ((f.step (n + 1)).le_iff _ _).mpr h
      rw [f.caps_coherent, f.origins_coherent] at hn
      exact Or.inl hn
    · have hn := ((f.step (n + 1)).le_iff _ _).mpr h
      rw [f.caps_coherent, f.origins_coherent] at hn
      exact Or.inr (Or.inl hn)
    · have hn := congrArg (f.step (n + 1)).toFun h
      rw [(f.step (n + 1)).map_meet, (f.step (n + 1)).map_meet,
        f.caps_coherent, f.caps_coherent, f.origins_coherent, f.origins_coherent] at hn
      exact Or.inr (Or.inr hn)

theorem original_below_cap (n : Nat) (i : Task) (v : A) :
    (f.order (n + 1)).le ((f.origin (n + 1)).toFun v) (f.cap n i) ↔ P.le v (f.datum i).target := by
  induction n with
  | zero =>
    change f.initial.batch.extension.le (.inl v) (f.initial.batch.represent i f.top) ↔ _
    rw [f.initial.batch.represent_new i f.top (f.source_proper i)]
    change P.le v (f.initial.batch.shadow ⟨i, ⟨f.top, f.source_proper i⟩⟩) ↔ _
    have hs := f.initial.batch.cap_shadow i f.top f.greatest (f.source_proper i)
    change f.initial.batch.shadow ⟨i, ⟨f.top, f.source_proper i⟩⟩ = _ at hs
    rw [hs]
    have hb : f.initial.batch.base i = (f.datum i).target := f.representative_target i
    rw [hb]
  | succ n ih =>
    rw [← f.caps_coherent n i, ← f.origins_coherent (n + 1) v]
    exact ((f.step (n + 1)).le_iff _ _).trans ih

theorem cap_strict (n : Nat) (i : Task) :
    (f.order (n + 1)).le ((f.origin (n + 1)).toFun (f.datum i).target) (f.cap n i) ∧
    ¬ (f.order (n + 1)).le (f.cap n i) ((f.origin (n + 1)).toFun (f.datum i).target) := by
  constructor
  · exact (f.original_below_cap n i _).mpr (P.refl _)
  · intro h
    rw [← f.maps_base n i] at h
    have lower := ((f.compression n i).le_iff _ _).mp h
    exact f.source_proper i (((f.origin n).le_iff _ _).mp lower)

theorem separator_not_below_cap (n : Nat) (i : Task) :
    ¬ (f.order (n + 1)).le ((f.origin (n + 1)).toFun (f.datum i).separator) (f.cap n i) :=
  fun h => (f.geometry i).separator_not_le_base ((f.original_below_cap n i _).mp h)

theorem stage_fresh_accounting (n : Nat) (z : (f.stages n).batch.Fresh) :
    ∃ (i : Task) (y : f.Point n), (f.compression n i).toFun y = .inr z ∧
      (f.order (n + 1)).le (.inr z) (f.cap n i) ∧
      ¬ (f.order (n + 1)).le (.inr z) ((f.origin (n + 1)).toFun (f.datum i).target) := by
  cases n with
  | zero =>
    rcases z with ⟨i, y, hy⟩
    have image := f.initial.batch.represent_new i y hy
    refine ⟨i, y, image, ?_, ?_⟩
    · have lower := f.range_below_cap 0 i y
      change f.initial.batch.extension.le (f.initial.batch.represent i y) _ at lower
      rw [image] at lower
      exact lower
    · exact fun h => (f.geometry i).separator_not_le_base
        ((f.geometry i).separator_le_filter _ h)
  | succ n =>
    rcases (f.stages n).inputs.fresh_accounting ((f.stages n).original.toFun f.top)
      (f.stages n).top z with ⟨i, y, image, lower, outside⟩
    refine ⟨i, y, image, lower, ?_⟩
    rw [← f.maps_base (n + 1) i]
    change ¬ (f.stages n).inputs.nextBatch.extension.le (.inr z)
      (.inl (((f.stages n).inputs.previous i).toFun ((f.stages n).original.toFun (f.datum i).source)))
    rw [← (f.stages n).source_original]
    exact outside

end PartitionPilot.Compression.RecursiveMaps.TaskSystem

end

end OAI