import OAI.Computability.Scheduling.HierarchyCompleteness

namespace OAI

section

namespace ThreeMachine.Structure
section Soundness
variable {J A : Type} [Fintype J] {r : J → J → Prop} {atoms : A → Set J}

structure FullBlock (r : J → J → Prop) (W : Set J) where
  length : ℕ
  time : J → ℕ
  bounds : ∀ x ∈ W, 1 ≤ time x ∧ time x ≤ length
  capacity : ∀ t, {x | x ∈ W ∧ time x = t}.ncard ≤ 3
  respects : ∀ x ∈ W, ∀ y ∈ W, r x y → time x < time y
  size : W.ncard = 3 * length

namespace FullBlock
variable {U V W : Set J}

def empty : FullBlock r (∅ : Set J) where
  length := 0
  time := fun _ => 0
  bounds := by simp
  capacity := by simp
  respects := by simp
  size := by simp

def triple (Z : Triple J) (hZ : ∀ x ∈ Z.val, ∀ y ∈ Z.val, ¬r x y) :
    FullBlock r (Z.val : Set J) where
  length := 1
  time := fun _ => 1
  bounds := by simp
  capacity := fun _ => (Set.ncard_le_ncard (fun _ hx => hx.1)).trans (by simpa using Z.property.le)
  respects := fun x hx y hy h => (hZ x hx y hy h).elim
  size := by simpa using Z.property

noncomputable def append (s : FullBlock r U) (t : FullBlock r V)
    (hd : Disjoint U V) (hback : ∀ x ∈ V, ∀ y ∈ U, ¬r x y) :
    FullBlock r (U ∪ V) := by
  classical
  let time : J → ℕ := fun x => if x ∈ U then s.time x else s.length + t.time x
  have htimeU (x : J) (hx : x ∈ U) : time x = s.time x := ite_eq_left hx
  have htimeV (x : J) (hx : x ∈ V) : time x = s.length + t.time x :=
    ite_eq_right (fun hu => Set.disjoint_left.mp hd hu hx)
  refine ⟨s.length + t.length, time, ?_, ?_, ?_, ?_⟩
  · intro x hx
    rcases hx with hx | hx
    · rw [htimeU x hx]
      have := s.bounds x hx
      omega
    · rw [htimeV x hx]
      have := t.bounds x hx
      omega
  · intro k
    by_cases hk : k ≤ s.length
    · have he : {x | x ∈ U ∪ V ∧ time x = k} = {x | x ∈ U ∧ s.time x = k} := by
        ext x
        constructor
        · rintro ⟨hx | hx, he⟩
          · exact ⟨hx, (htimeU x hx).symm.trans he⟩
          · rw [htimeV x hx] at he
            have := t.bounds x hx
            omega
        · rintro ⟨hx, he⟩
          exact ⟨Or.inl hx, (htimeU x hx).trans he⟩
      rw [he]
      exact s.capacity k
    · have he : {x | x ∈ U ∪ V ∧ time x = k} =
          {x | x ∈ V ∧ t.time x = k - s.length} := by
        ext x
        constructor
        · rintro ⟨hx | hx, he⟩
          · rw [htimeU x hx] at he
            have := s.bounds x hx
            omega
          · rw [htimeV x hx] at he
            exact ⟨hx, by omega⟩
        · rintro ⟨hx, he⟩
          refine ⟨Or.inr hx, ?_⟩
          rw [htimeV x hx, he]
          omega
      rw [he]
      exact t.capacity (k-s.length)
  · intro x hx y hy hxy
    rcases hx with hx | hx <;> rcases hy with hy | hy
    · simpa only [htimeU x hx, htimeU y hy] using s.respects x hx y hy hxy
    · rw [htimeU x hx, htimeV y hy]
      have := s.bounds x hx
      have := t.bounds y hy
      omega
    · exact (hback x hx y hy hxy).elim
    · simpa only [htimeV x hx, htimeV y hy, Nat.add_lt_add_iff_left] using
        t.respects x hx y hy hxy
  · rw [Set.ncard_union_eq hd, s.size, t.size, Nat.mul_add]

end FullBlock

namespace SplitVertex
variable {W : Set J} {u v : SplitVertex r atoms W}

omit [Fintype J] in
theorem gap_subset_right (_huv : u.left ∪ u.middle.val ⊆ v.left) :
    v.left \ (u.left ∪ u.middle.val) ⊆ u.right := by
  intro x hx
  rw [u.right_eq]
  exact ⟨v.left_subset hx.1, hx.2⟩

omit [Fintype J] in
theorem left_union_gap (huv : u.left ∪ u.middle.val ⊆ v.left) :
    (u.left ∪ u.middle.val) ∪ (v.left \ (u.left ∪ u.middle.val)) = v.left := by
  ext x
  constructor
  · intro hx
    exact hx.elim (fun h => huv h) (fun h => h.1)
  · intro hx
    by_cases hu : x ∈ u.left ∪ u.middle.val
    · exact Or.inl hu
    · exact Or.inr ⟨hx, hu⟩

noncomputable def add_middle (v : SplitVertex r atoms W) (s : FullBlock r v.left) :
    FullBlock r (v.left ∪ v.middle.val) :=
  s.append (FullBlock.triple v.middle v.antichain) v.left_middle v.no_middle_left

noncomputable def advance (s : FullBlock r u.left)
    (huv : u.left ∪ u.middle.val ⊆ v.left)
    (t : FullBlock r (v.left \ (u.left ∪ u.middle.val))) : FullBlock r v.left := by
  have hd : Disjoint (u.left ∪ u.middle.val) (v.left \ (u.left ∪ u.middle.val)) := by
    exact Set.disjoint_left.mpr (fun _ hx hy => hy.2 hx)
  have hback : ∀ x ∈ v.left \ (u.left ∪ u.middle.val),
      ∀ y ∈ u.left ∪ u.middle.val, ¬r x y := by
    intro x hx y hy
    have hxr := gap_subset_right huv hx
    exact hy.elim (u.no_right_left x hxr y) (u.no_right_middle x hxr y)
  exact left_union_gap huv ▸ (u.add_middle s).append t hd hback

noncomputable def finish (v : SplitVertex r atoms W)
    (s : FullBlock r v.left) (t : FullBlock r v.right) : FullBlock r W := by
  have hd : Disjoint (v.left ∪ v.middle.val) v.right := v.left_right.union_left v.middle_right
  have hback : ∀ x ∈ v.right, ∀ y ∈ v.left ∪ v.middle.val, ¬r x y := by
    intro x hx y hy
    exact hy.elim (v.no_right_left x hx y) (v.no_right_middle x hx y)
  have he : (v.left ∪ v.middle.val) ∪ v.right = W := by
    ext x
    simpa only [Set.mem_union, Finset.mem_coe, or_assoc] using (v.partition x).symm
  exact he ▸ (v.add_middle s).append t hd hback

theorem path_sound {P : Set J → Prop} (hP : ∀ U, P U → Nonempty (FullBlock r U))
    (h : Relation.ReflTransGen (Step P) u v) (hs : Nonempty (FullBlock r u.left)) :
    Nonempty (FullBlock r v.left) := by
  induction h with
  | refl => exact hs
  | tail _ ht ih =>
    obtain ⟨s⟩ := ih
    obtain ⟨t⟩ := hP _ ht.2
    exact ⟨advance s ht.1 t⟩

end SplitVertex

theorem AcceptedAt.sound {n : ℕ} {W : Set J} (h : AcceptedAt r atoms n W) :
    Nonempty (FullBlock r W) := by
  induction n generalizing W with
  | zero => exact h.2 ▸ ⟨FullBlock.empty⟩
  | succ n ih =>
    rcases h.2 with he | ⟨u, v, hu, hp, hv⟩
    · exact he ▸ ⟨FullBlock.empty⟩
    · obtain ⟨s⟩ := SplitVertex.path_sound (fun _ h => ih h) hp (ih hu)
      obtain ⟨t⟩ := ih hv
      exact ⟨v.finish s t⟩

end Soundness
end ThreeMachine.Structure

namespace ThreeMachine.Structure
section AtomicFamily
variable {J : Type} [Fintype J]

inductive Atomic (J : Type) [Fintype J]
  | constant (value : Bool)
  | threshold (frame upper : Bool) (k : Fin (Fintype.card J + 2))
  | cone (frame : Bool) (kind : Fin 5) (Z : Triple J)
  deriving Fintype

namespace Atomic

def eval (r : J → J → Prop) (rank reverseRank : J → ℕ) : Atomic J → Set J
  | .constant b => if b then Set.univ else ∅
  | .threshold frame upper k =>
    let ρ := if frame then reverseRank else rank
    if upper then {x | ρ x ≤ k.val} else {x | k.val ≤ ρ x}
  | .cone frame kind Z =>
    let R := if frame then (fun x y => r y x) else r
    match kind.val with
    | 0 => Z.val
    | 1 => (Boundary.actual Z).pred R
    | 2 => (Boundary.actual Z).desc R
    | 3 => (Boundary.actual Z).weakPred R
    | _ => (Boundary.actual Z).weakDesc R

theorem eval_reversed (r : J → J → Prop) (rank reverseRank : J → ℕ)
    (a : Atomic J) :
    ∃ b : Atomic J, eval (fun x y => r y x) reverseRank rank a = eval r rank reverseRank b := by
  cases a with
  | constant b => exact ⟨.constant b, rfl⟩
  | threshold frame upper k =>
    refine ⟨.threshold (!frame) upper k, ?_⟩
    cases frame <;> rfl
  | cone frame kind Z =>
    refine ⟨.cone (!frame) kind Z, ?_⟩
    cases frame <;> rfl

theorem support (r : J → J → Prop) (rank reverseRank : J → ℕ)
    (hrank : ∀ x, rank x ≤ Fintype.card J) :
    AtomSupport (eval r rank reverseRank) r rank := by
  have htrue : Described (eval r rank reverseRank) Set.univ 1 :=
    Described.atom (atoms := eval r rank reverseRank) (.constant true)
  have hfalse : Described (eval r rank reverseRank) ∅ 1 :=
    Described.atom (atoms := eval r rank reverseRank) (.constant false)
  refine ⟨htrue, hfalse, ?_, ?_, ?_, ?_, ?_, ?_⟩
  · intro k
    by_cases hk : k < Fintype.card J + 2
    · exact Described.atom (atoms := eval r rank reverseRank) (.threshold false false ⟨k, hk⟩)
    · have he : RankTail rank k = ∅ := by
        ext x
        have := hrank x
        simp only [RankTail, Set.mem_ofPred_eq, Set.mem_empty_iff_false, iff_false]
        omega
      exact he ▸ hfalse
  · intro B
    cases B with
    | left => exact hfalse
    | right => exact htrue
    | actual Z => exact Described.atom (atoms := eval r rank reverseRank) (.cone false 1 Z)
  · intro B
    cases B with
    | left => exact htrue
    | right => exact hfalse
    | actual Z => exact Described.atom (atoms := eval r rank reverseRank) (.cone false 2 Z)
  · intro B
    cases B with
    | left => exact hfalse
    | right => exact htrue
    | actual Z => exact Described.atom (atoms := eval r rank reverseRank) (.cone false 3 Z)
  · intro B
    cases B with
    | left => exact htrue
    | right => exact hfalse
    | actual Z => exact Described.atom (atoms := eval r rank reverseRank) (.cone false 4 Z)
  · intro Z
    exact Described.atom (atoms := eval r rank reverseRank) (.cone false 0 Z)

theorem support_reverse (r : J → J → Prop) (rank reverseRank : J → ℕ)
    (hrank : ∀ x, reverseRank x ≤ Fintype.card J) :
    AtomSupport (eval r rank reverseRank) (fun x y => r y x) reverseRank := by
  have transfer (S : Set J) (h : Described (eval (fun x y => r y x) reverseRank rank) S 1) :
      Described (eval r rank reverseRank) S 1 := by
    obtain ⟨f, hf, hk⟩ := h
    cases f with
    | leaf a b =>
      obtain ⟨a', ha'⟩ := eval_reversed r rank reverseRank a
      refine ⟨.leaf a' b, ?_, le_rfl⟩
      cases b <;> simpa only [Formula.eval, ha'] using hf
    | conj p q | disj p q =>
      have := p.leaves_pos
      have := q.leaves_pos
      simp only [Formula.leaves] at hk
      omega
  have h := support (fun x y => r y x) reverseRank rank hrank
  exact ⟨transfer _ h.truth, transfer _ h.falsity, fun k => transfer _ (h.rankTail k),
    fun B => transfer _ (h.pred B), fun B => transfer _ (h.desc B),
    fun B => transfer _ (h.weakPred B), fun B => transfer _ (h.weakDesc B),
    fun Z => transfer _ (h.triple Z)⟩

end Atomic
end AtomicFamily
end ThreeMachine.Structure

namespace ThreeMachine.Structure
section Ranks
variable {J K : Type} [Fintype J] [LinearOrder K]

def rankOfKey (key : J → K) (x : J) : ℕ :=
  (Finset.univ.filter (fun y => key y < key x)).card + 1

theorem rankOfKey_strict {key : J → K} {x y : J} (h : key x < key y) :
    rankOfKey key x < rankOfKey key y := by
  have hsub : Finset.univ.filter (fun z => key z < key x) ⊂
      Finset.univ.filter (fun z => key z < key y) := by
    refine Finset.ssubset_iff_subset_ne.mpr ⟨?_, ?_⟩
    · intro z hz
      exact Finset.mem_filter.mpr ⟨Finset.mem_univ _, (Finset.mem_filter.mp hz).2.trans h⟩
    · intro he
      have hm : x ∈ Finset.univ.filter (fun z => key z < key y) :=
        Finset.mem_filter.mpr ⟨Finset.mem_univ _, h⟩
      rw [← he] at hm
      exact lt_irrefl _ (Finset.mem_filter.mp hm).2
  have := Finset.card_lt_card hsub
  dsimp [rankOfKey]
  omega

theorem rankOfKey_bounds (key : J → K) (x : J) :
    1 ≤ rankOfKey key x ∧ rankOfKey key x ≤ Fintype.card J := by
  have hsub : Finset.univ.filter (fun y => key y < key x) ⊂ (Finset.univ : Finset J) := by
    refine Finset.ssubset_iff_subset_ne.mpr ⟨Finset.filter_subset _ _, ?_⟩
    intro he
    have hm : x ∈ Finset.univ.filter (fun y => key y < key x) := by rw [he]; exact Finset.mem_univ _
    exact lt_irrefl _ (Finset.mem_filter.mp hm).2
  have := Finset.card_lt_card hsub
  simp only [Finset.card_univ] at this
  dsimp [rankOfKey]
  omega

theorem rankOfKey_injective {key : J → K} (hinj : Function.Injective key) :
    Function.Injective (rankOfKey key) := by
  intro x y he
  rcases lt_trichotomy (key x) (key y) with h | h | h
  · have := rankOfKey_strict h
    omega
  · exact hinj h
  · have := rankOfKey_strict h
    omega

end Ranks

section IndexedRanks
variable {n : ℕ} (r : Fin n → Fin n → Prop) [DecidableRel r]

def predecessorCount (x : Fin n) : ℕ := (Finset.univ.filter (fun y => r y x)).card

def jobKey (x : Fin n) : Lex (ℕ × Fin n) := toLex (predecessorCount r x, x)

def jobRank : Fin n → ℕ := rankOfKey (jobKey r)

def reverseJobRank (x : Fin n) : ℕ := n+1-jobRank r x

theorem jobKey_injective : Function.Injective (jobKey r) := by
  intro x y h
  exact congrArg (fun z : Lex (ℕ × Fin n) => (ofLex z).2) h

theorem jobRank_injective : Function.Injective (jobRank r) := rankOfKey_injective (jobKey_injective r)

theorem jobRank_bounds (x : Fin n) : 1 ≤ jobRank r x ∧ jobRank r x ≤ n := by
  simpa [jobRank] using rankOfKey_bounds (jobKey r) x

theorem jobRank_strict
    (hirr : ∀ x, ¬r x x) (htrans : ∀ ⦃x y z⦄, r x y → r y z → r x z)
    {x y : Fin n} (hxy : r x y) : jobRank r x < jobRank r y := by
  have hsub : Finset.univ.filter (fun z => r z x) ⊂ Finset.univ.filter (fun z => r z y) := by
    refine Finset.ssubset_iff_subset_ne.mpr ⟨?_, ?_⟩
    · intro z hz
      exact Finset.mem_filter.mpr ⟨Finset.mem_univ _, htrans (Finset.mem_filter.mp hz).2 hxy⟩
    · intro he
      have hm : x ∈ Finset.univ.filter (fun z => r z y) := Finset.mem_filter.mpr ⟨Finset.mem_univ _, hxy⟩
      rw [← he] at hm
      exact hirr x (Finset.mem_filter.mp hm).2
  apply rankOfKey_strict
  exact Prod.Lex.toLex_lt_toLex.mpr (Or.inl (Finset.card_lt_card hsub))

theorem reverseJobRank_bounds (x : Fin n) : 1 ≤ reverseJobRank r x ∧ reverseJobRank r x ≤ n := by
  have := jobRank_bounds r x
  dsimp [reverseJobRank]
  omega

theorem reverseJobRank_injective : Function.Injective (reverseJobRank r) := by
  intro x y h
  apply jobRank_injective r
  have := jobRank_bounds r x
  have := jobRank_bounds r y
  dsimp [reverseJobRank] at h
  omega

theorem reverseJobRank_strict
    (hirr : ∀ x, ¬r x x) (htrans : ∀ ⦃x y z⦄, r x y → r y z → r x z)
    {x y : Fin n} (hxy : r y x) : reverseJobRank r x < reverseJobRank r y := by
  have := jobRank_strict r hirr htrans hxy
  have := jobRank_bounds r x
  dsimp [reverseJobRank]
  omega

end IndexedRanks
end ThreeMachine.Structure

namespace ThreeMachine.Structure
section ScheduleLayouts
variable {J : Type} [Fintype J]

theorem exists_slot_embedding {T : ℕ} (time : J → ℕ)
    (hbound : ∀ x, 1 ≤ time x ∧ time x ≤ T)
    (hcap : ∀ t, {x | time x = t}.ncard ≤ 3) :
    ∃ f : J → Fin (3*T), Function.Injective f ∧
      ∀ x, (f x).val / 3 + 1 = time x := by
  classical
  let slot : J → Fin T := fun x => ⟨time x - 1, by have := hbound x; omega⟩
  have hc (i : Fin T) : Fintype.card {x // slot x = i} ≤ 3 := by
    have he : {x | slot x = i} = {x | time x = i.val + 1} := by
      ext x
      simp only [Set.mem_ofPred_eq, Fin.ext_iff]
      change time x - 1 = i.val ↔ time x = i.val + 1
      have := hbound x
      omega
    rw [← Nat.card_eq_fintype_card]
    change {x | slot x = i}.ncard ≤ 3
    rw [he]
    exact hcap _
  let embed (i : Fin T) : {x // slot x = i} ↪ Fin 3 :=
    (Fintype.equivFin {x // slot x = i}).toEmbedding.trans
      (Fin.castLEEmb (by simpa using hc i))
  let code : (Σ i : Fin T, {x // slot x = i}) → Fin T × Fin 3 :=
    fun z => (z.1, embed z.1 z.2)
  have hcode : Function.Injective code := by
    rintro ⟨i, x⟩ ⟨j, y⟩ he
    obtain ⟨hij, hxy⟩ := Prod.mk.inj he
    cases hij
    have hxy' := (embed i).injective hxy
    change x = y at hxy'
    subst y
    rfl
  let f₀ : J → Fin T × Fin 3 := code ∘ (Equiv.sigmaFiberEquiv slot).symm
  have hf : Function.Injective f₀ := hcode.comp (Equiv.sigmaFiberEquiv slot).symm.injective
  let conv : Fin T × Fin 3 ≃ Fin (3*T) :=
    finProdFinEquiv.trans (finCongr (Nat.mul_comm T 3))
  let f : J → Fin (3*T) := conv ∘ f₀
  refine ⟨f, conv.injective.comp hf, ?_⟩
  intro x
  have hidx : (embed (slot x) ⟨x, rfl⟩).val < 3 := (embed (slot x) ⟨x, rfl⟩).isLt
  change ((embed (slot x) ⟨x, rfl⟩).val + 3 * (slot x).val) / 3 + 1 = time x
  change ((embed (slot x) ⟨x, rfl⟩).val + 3 * (time x - 1)) / 3 + 1 = time x
  have := hbound x
  omega

theorem exists_layout_time {T : ℕ} (time : J → ℕ)
    (hbound : ∀ x, 1 ≤ time x ∧ time x ≤ T)
    (hcap : ∀ t, {x | time x = t}.ncard ≤ 3)
    (hsize : Fintype.card J = 3 * T) :
    ∃ p : Layout J, ∀ x, p.time x = time x := by
  obtain ⟨f, hf, ht⟩ := exists_slot_embedding time hbound hcap
  let e : J ≃ Fin (3*T) := Equiv.ofBijective f
    ((Fintype.bijective_iff_injective_and_card f).mpr ⟨hf, by simpa using hsize⟩)
  let p : Layout J := e.trans (finCongr hsize.symm)
  exact ⟨p, ht⟩

theorem FullBlock.layout {r : J → J → Prop} (s : FullBlock r Set.univ) :
    ∃ p : Layout J, p.Full r := by
  have hsize : Fintype.card J = 3*s.length := by
    simpa only [Set.ncard_univ, Nat.card_eq_fintype_card] using s.size
  obtain ⟨p, hp⟩ := exists_layout_time s.time (fun x => s.bounds x (Set.mem_univ x))
    (fun t => by simpa only [Set.mem_univ, true_and] using s.capacity t) hsize
  refine ⟨p, ⟨s.length, hsize⟩, ?_⟩
  intro x y hxy
  simpa only [hp] using s.respects x (Set.mem_univ x) y (Set.mem_univ y) hxy

theorem accepted_iff_full_layout [DecidableEq J]
    (r : J → J → Prop) (rank reverseRank : J → ℕ)
    (htrans : ∀ ⦃x y z⦄, r x y → r y z → r x z)
    (hrank : ∀ x, rank x ≤ Fintype.card J)
    (hrankR : ∀ x, reverseRank x ≤ Fintype.card J)
    (hinj : Function.Injective rank) (hinjR : Function.Injective reverseRank)
    (hstrict : ∀ x y, r x y → rank x < rank y)
    (hstrictR : ∀ x y, r y x → reverseRank x < reverseRank y) :
    AcceptedAt r (Atomic.eval r rank reverseRank) (Fintype.card J) Set.univ ↔
      ∃ p : Layout J, p.Full r := by
  constructor
  · intro h
    obtain ⟨s⟩ := h.sound
    exact s.layout
  · rintro ⟨p, hp⟩
    have hA := Atomic.support r rank reverseRank hrank
    exact node_complete (Fintype.card J) r rank reverseRank p Set.univ
      (Fintype.card J+1) htrans hA (Atomic.support_reverse r rank reverseRank hrankR)
      (by omega) (fun x => by have := hrank x; omega)
      (fun x => by have := hrankR x; omega) hinj hinjR hstrict hstrictR
      (NodeData.root p hp hA) (by simp)

end ScheduleLayouts
end ThreeMachine.Structure

end

end OAI