import OAI.Computability.Scheduling.UniformRoutines

namespace OAI

universe u1 u2 u3 u4 u5 u6 u7 u8 u9 u10 u11 u12 u13 u14 u15

section

namespace ThreeMachine.StackCompiler

instance (n : ℕ) : Coding (Fin n) := ⟨fun x => enc x.val⟩
instance (n : ℕ) : Coding (Finset (Fin n)) := ⟨fun s => enc (s.sort (· ≤ ·))⟩

@[simp] theorem enc_fin {n : ℕ} (x : Fin n) : enc x = enc x.val := rfl
@[simp] theorem volume_fin {n : ℕ} (x : Fin n) : volume x = 2*x.val+1 := volume_nat x.val
@[simp] theorem enc_finset {n : ℕ} (s : Finset (Fin n)) :
    enc s = enc (s.sort (· ≤ ·)) := rfl

structure Cardinal (n : ℕ) where
  trivial : Unit
instance (n : ℕ) : Coding (Cardinal n) := ⟨fun _ => enc n⟩

structure Universe (n : ℕ) where
  trivial : Unit
instance (n : ℕ) : Coding (Universe n) := ⟨fun _ => enc (List.finRange n)⟩

theorem enc_list_map {α : Type u1} {β : Type u2} [Coding α] [Coding β] (f : α → β)
    (hf : ∀ x, enc (f x) = enc x) (xs : List α) : enc (xs.map f) = enc xs := by
  induction xs with
  | nil => rfl
  | cons a xs ih => simp only [List.map_cons,enc_cons,hf,ih]

theorem sort_filter {n : ℕ} (s : Finset (Fin n)) (p : Fin n → Bool) :
    (s.filter (fun x => p x)).sort (· ≤ ·) = (s.sort (· ≤ ·)).filter p := by
  have he : ((s.sort (· ≤ ·)).filter p).toFinset = s.filter (fun x => p x) := by
    ext x; simp
  rw [← he]
  exact (List.toFinset_sort (· ≤ ·) ((s.sort_nodup (· ≤ ·)).filter p)).mpr
    ((s.pairwise_sort (· ≤ ·)).filter p)

namespace Uniform

def finVal : Uniform (fun n (x : Fin n) => x.val) := reinterpret _ (fun _ _ => rfl)

def finEq : Uniform (fun n (x : Fin n × Fin n) => decide (x.1 = x.2)) :=
  (((fst.comp finVal).pair (snd.comp finVal)).comp (Realizer.eqNat.uniform ℕ)).congr
    (fun _ x => by simp only [Function.comp_apply,Fin.val_inj])

def cardinal : Uniform (fun n (_ : Cardinal n) => n) := reinterpret _ (fun _ _ => rfl)

def universeList : Uniform (fun n (_ : Universe n) => List.finRange n) :=
  reinterpret _ (fun _ _ => rfl)

def universeSet : Uniform (fun n (_ : Universe n) => (Finset.univ : Finset (Fin n))) :=
  reinterpret _ (fun n _ => by simp only [enc_finset,Fin.sort_univ]; rfl)

def setList : Uniform (fun n (s : Finset (Fin n)) => s.sort (· ≤ ·)) :=
  reinterpret _ (fun _ _ => rfl)

def setEmpty : Uniform (fun n (_ : Universe n) => (∅ : Finset (Fin n))) where
  transform := fun _ => .nil
  charge := _
  routine := Routine.nil
  correct _ _ := by simp only [enc_finset,Finset.sort_empty]; rfl

def setIsEmpty : Uniform (fun n (s : Finset (Fin n)) => decide (s = ∅)) :=
  ((setList.comp isCons).comp (Realizer.not.uniform ℕ)).congr (fun _ x => by
    by_cases h : x = ∅
    · subst x; simp
    · have hh : x.sort (· ≤ ·) ≠ [] := by
        intro he; have := congrArg List.toFinset he
        exact h (by simpa only [Finset.sort_toFinset,List.toFinset_nil] using this)
      simp [Function.comp_apply,List.isEmpty_eq_false_iff,hh,h])

def setCard : Uniform (fun n (s : Finset (Fin n)) => s.card) :=
  (setList.comp length).congr (fun _ _ => Finset.length_sort (· ≤ ·))

def setFilter {γ : ℕ → Type u3} [∀ n, Coding (γ n)]
    {p : ∀ n, Fin n × γ n → Bool} (P : Uniform p) :
    Uniform (fun n (x : Finset (Fin n) × γ n) => x.1.filter (fun a => p n (a,x.2))) where
  transform := (setList.onFst.comp P.filter).transform
  charge := (setList.onFst.comp P.filter).charge
  routine := (setList.onFst.comp P.filter).routine
  correct n x := by
    rw [(setList.onFst.comp P.filter).correct]
    simp only [Function.comp_apply,enc_finset,sort_filter]

def setMem : Uniform (fun n (x : Fin n × Finset (Fin n)) => decide (x.1 ∈ x.2)) :=
  ((((snd.comp setList).pair fst).comp finEq.any)).congr (fun _ x => by
    apply Bool.eq_iff_iff.mpr
    simp only [Function.comp_apply,List.any_eq_true,decide_eq_true_eq]
    simp)

def setInter : Uniform (fun n (x : Finset (Fin n) × Finset (Fin n)) => x.1 ∩ x.2) :=
  setMem.setFilter.congr (fun _ x => by ext a; simp)

def setDiff : Uniform (fun n (x : Finset (Fin n) × Finset (Fin n)) => x.1 \ x.2) :=
  (setMem.comp (Realizer.not.uniform ℕ)).setFilter.congr (fun _ x => by ext a; simp)

def setSubset : Uniform (fun n (x : Finset (Fin n) × Finset (Fin n)) => decide (x.1 ⊆ x.2)) :=
  ((setList.onFst).comp setMem.all).congr (fun _ x => by
    apply Bool.eq_iff_iff.mpr
    simp only [Function.comp_apply,List.all_eq_true,decide_eq_true_eq,Finset.mem_sort]
    rfl)

def setEq : Uniform (fun n (x : Finset (Fin n) × Finset (Fin n)) => decide (x.1 = x.2)) :=
  ((setSubset.pair (swap.comp setSubset)).comp (Realizer.and.uniform ℕ)).congr (fun _ x => by
    apply Bool.eq_iff_iff.mpr
    simp [Finset.Subset.antisymm_iff])

def setDisjoint : Uniform (fun n (x : Finset (Fin n) × Finset (Fin n)) => decide (Disjoint x.1 x.2)) :=
  (setInter.comp setIsEmpty).congr (fun _ x => by
    simp only [Function.comp_apply,Finset.disjoint_iff_inter_eq_empty])

def setUnionBody : Uniform (fun n (x : Fin n × (Finset (Fin n) × Finset (Fin n))) =>
    decide (x.1 ∈ x.2.1 ∨ x.1 ∈ x.2.2)) :=
  ((((fst.pair (snd.comp fst)).comp setMem).pair
      ((fst.pair (snd.comp snd)).comp setMem)).comp (Realizer.or.uniform ℕ)).congr (fun _ _ => by simp)

def setUnion : Uniform (fun n (x : Universe n × (Finset (Fin n) × Finset (Fin n))) =>
    x.2.1 ∪ x.2.2) :=
  (((fst.comp universeSet).pair snd).comp setUnionBody.setFilter).congr (fun _ x => by
    ext a; simp)

def setCompl : Uniform (fun n (x : Universe n × Finset (Fin n)) => x.2ᶜ) :=
  (((fst.comp universeSet).pair snd).comp setDiff).congr (fun _ x => (Finset.compl_eq_univ_sdiff x.2).symm)

end Uniform
end ThreeMachine.StackCompiler

namespace ThreeMachine.StackCompiler
namespace Realizer

def rangeStep : Realizer (fun x : ℕ × List ℕ => (x.1+1,x.1 :: x.2)) :=
  (fst.comp succ).pair cons

theorem rangeStep_iterate (n : ℕ) :
    (fun x : ℕ × List ℕ => (x.1+1,x.1 :: x.2))^[n] (0,[]) = (n,(List.range n).reverse) := by
  induction n with
  | zero => rfl
  | succ n ih => rw [Function.iterate_succ_apply',ih]; simp [List.range_succ]

def range : Realizer List.range :=
  (((id.pair (zero.pair nil)).comp rangeStep.iterate).comp (snd.comp reverse)).congr (fun n => by
    simp only [Function.comp_apply,rangeStep_iterate,List.reverse_reverse,id_eq])

end Realizer

theorem finRange_val (n : ℕ) : (List.finRange n).map Fin.val = List.range n := by
  induction n with
  | zero => rfl
  | succ n ih =>
    rw [List.finRange_succ_last,List.map_append,List.map_map]
    simpa only [Function.comp_def,Fin.val_castSucc,List.map_cons,List.map_nil,Fin.val_last,ih]
      using (List.range_succ (n := n)).symm

namespace Uniform

def makeUniverse : Uniform (fun n (_ : Cardinal n) => (Universe.mk () : Universe n)) where
  transform := Realizer.range.transform
  charge := Realizer.range.charge
  routine := Realizer.range.routine
  correct n _ := by
    change Realizer.range.transform (enc n) = enc (List.finRange n)
    rw [Realizer.range.correct,← finRange_val]
    exact enc_list_map Fin.val (fun _ => rfl) _

def numLength : Uniform (fun (_ : ℕ) (x : List ℕ) => x.length) := length

end Uniform
end ThreeMachine.StackCompiler

namespace ThreeMachine.StackCompiler
variable {α : Type u4} [Coding α]

theorem volume_append (xs ys : List α) : volume (xs ++ ys)+1 = volume xs+volume ys := by
  induction xs with
  | nil => simp [Nat.add_comm]
  | cons a xs ih => simp only [List.cons_append,volume_cons]; omega

theorem volume_reverse (xs : List α) : volume xs.reverse = volume xs := by
  induction xs with
  | nil => rfl
  | cons a xs ih =>
    rw [List.reverse_cons]
    have := volume_append xs.reverse [a]
    simp only [volume_cons,volume_nil,ih] at this ⊢
    omega

theorem volume_filter (p : α → Bool) (xs : List α) : volume (xs.filter p) ≤ volume xs := by
  induction xs with
  | nil => rfl
  | cons a xs ih =>
    cases he : p a <;> simp only [List.filter_cons,he,Bool.false_eq_true,ite_false,ite_true,volume_cons]
    · omega
    · omega

namespace Uniform
variable {I : Type u5} {α : I → Type u6} {β : I → Type u7} {γ : I → Type u8}
variable [∀ i, Coding (α i)] [∀ i, Coding (β i)] [∀ i, Coding (γ i)]
variable {f : ∀ i, α i → β i} {g : ∀ i, β i → γ i}

@[simp] theorem time_id (i : I) (x : α i) :
    (id : Uniform (fun i (x : α i) => x)).time i x = volume x+2 := rfl
@[simp] theorem time_fst (i : I) (x : α i × β i) :
    (fst : Uniform (fun i (x : α i × β i) => x.1)).time i x = volume x+2 := rfl
@[simp] theorem time_snd (i : I) (x : α i × β i) :
    (snd : Uniform (fun i (x : α i × β i) => x.2)).time i x = volume x+2 := rfl
@[simp] theorem time_nil (i : I) (x : α i) :
    (nil : Uniform (fun i (_ : α i) => ([] : List (β i)))).time i x = 2 := rfl
@[simp] theorem time_unit (i : I) (x : α i) :
    (unit : Uniform (fun i (_ : α i) => ())).time i x = 2 := rfl
@[simp] theorem time_zero (i : I) (x : α i) :
    (zero : Uniform (fun i (_ : α i) => (0 : ℕ))).time i x = 2 := rfl
@[simp] theorem time_false (i : I) (x : α i) :
    (false : Uniform (fun i (_ : α i) => Bool.false)).time i x = 2 := rfl
@[simp] theorem time_congr {f' : ∀ i, α i → β i} (R : Uniform f)
    (h : ∀ i x, f i x = f' i x) (i : I) (x : α i) :
    (R.congr h).time i x = R.time i x := rfl
@[simp] theorem time_reinterpret (f : ∀ i, α i → β i) (h : ∀ i x, enc (f i x) = enc x)
    (i : I) (x : α i) : (reinterpret f h).time i x = volume x+2 := rfl
@[simp] theorem time_cons (i : I) (x : α i × List (α i)) : cons.time i x = volume x+2 := rfl

theorem time_comp (R : Uniform f) (S : Uniform g) (i : I) (x : α i) :
    (R.comp S).time i x = R.time i x+S.time i (f i x)+10*(volume (f i x)+1) := by
  simp only [comp,time,Routine.comp,R.correct,volume]

theorem time_pair {g : ∀ i, α i → γ i} (R : Uniform f) (S : Uniform g) (i : I) (x : α i) :
    (R.pair S).time i x = R.time i x+S.time i x+20*(volume x+volume (f i x)+volume (g i x)+1) := by
  simp only [pair,time,Routine.pair,R.correct,S.correct,volume]

theorem time_fold {F : ∀ i, α i × β i → β i} (R : Uniform F) (i : I) (x : List (α i) × β i) :
    R.fold.time i x = 2*volume x+6+Realizer.foldTime (R.specialize i) x.2 x.1 :=
  (R.specialize i).time_fold x

theorem time_choose {g : ∀ i, α i → β i} (R : Uniform f) (S : Uniform g)
    (i : I) (x : Bool × α i) :
    (R.choose S).time i x = ((snd (α := fun _ : I => Bool) (β := α)).comp R).time i x+
      ((snd (α := fun _ : I => Bool) (β := α)).comp S).time i x+
      30*(volume x+volume (f i x.2)+volume (g i x.2)+1) :=
  (R.specialize i).time_choose (S.specialize i) x

theorem time_constant {δ : Type u9} [Coding δ] (a : δ) (i : I) (x : α i) :
    (constant a : Uniform (fun i (_ : α i) => a)).time i x =
      (2*volume a+1)*(20*volume x+50*volume a+50) := rfl

theorem time_reverse (i : I) (xs : List (α i)) :
    reverse.time i xs ≤ 200*(xs.length+1)*(volume xs+1) := by
  have hf : ∀ (xs ys : List (α i)),
      Realizer.foldTime ((cons : Uniform (fun i (x : α i × List (α i)) => x.1 :: x.2)).specialize i) ys xs ≤
        xs.length * (100*(volume xs+volume ys+1))+1 := by
    intro xs; induction xs with
    | nil => intro ys; simp only [Realizer.foldTime,List.length_nil,Nat.zero_mul,Nat.zero_add]; rfl
    | cons a xs ih =>
      intro ys
      have hh := ih (a :: ys)
      change volume (a,ys)+2+Realizer.foldTime _ (a :: ys) xs+
        20*(volume (a :: xs)+volume ys+volume (a :: ys)+1) ≤ _
      simp only [volume_pair,volume_cons,List.length_cons] at hh ⊢
      nlinarith [volume_pos a,volume_pos xs,volume_pos ys]
  simp only [reverse,time_congr,time_comp,time_pair,time_id,time_nil,time_fold,volume_pair,volume_nil]
  have hh := hf xs []
  simp only [volume_nil] at hh
  nlinarith [volume_pos xs]

end Uniform
end ThreeMachine.StackCompiler

namespace ThreeMachine.StackCompiler

instance {α : Type u10} [Coding α] (n : ℕ) : Coding (Fin n → α) := ⟨fun f => enc (List.ofFn f)⟩

@[simp] theorem enc_function {α : Type u11} [Coding α] {n : ℕ} (f : Fin n → α) :
    enc f = enc (List.ofFn f) := rfl

namespace Uniform
variable {I : Type u12} {α : I → Type u13} [∀ i, Coding (α i)]

def tail : Uniform (fun (i : I) (xs : List (α i)) => xs.tail) :=
  ⟨Data.tail,_,Routine.select Bool.false,fun _ xs => by cases xs <;> rfl⟩

def drop : Uniform (fun (i : I) (x : List (α i) × ℕ) => x.1.drop x.2) :=
  (swap.comp tail.iterate).congr (fun i x => by
    dsimp only [Function.comp_apply]
    have h : ∀ (n : ℕ) (xs : List (α i)), List.tail^[n] xs = xs.drop n := by
      intro n; induction n with
      | zero => intro xs; rfl
      | succ n ih => intro xs; rw [Function.iterate_succ_apply,ih,List.drop_tail]
    exact h x.2 x.1)

def getElem? : Uniform (fun (i : I) (x : List (α i) × ℕ) => x.1[x.2]?) :=
  (drop.comp head?).congr (fun _ _ => by simp only [Function.comp_apply,List.head?_drop])

def getElemD : Uniform (fun (i : I) (x : (List (α i) × ℕ) × α i) => x.1.1.getD x.1.2 x.2) :=
  (getElem?.onFst.comp getD).congr (fun _ _ => List.getD_eq_getElem?_getD.symm)

end Uniform

namespace Uniform
variable {α : ℕ → Type u14} {β : ℕ → Type u15} [∀ n, Coding (α n)] [∀ n, Coding (β n)]

def functionList : Uniform (fun n (f : Fin n → α n) => List.ofFn f) :=
  reinterpret _ (fun _ _ => rfl)

def functionGetOption : Uniform (fun n (x : (Fin n → α n) × Fin n) => Option.some (x.1 x.2)) :=
  (((fst.comp functionList).pair (snd.comp finVal)).comp getElem?).congr (fun _ x => by
    simp only [Function.comp_apply,List.getElem?_ofFn,dite_eq_left x.2.isLt])

def functionGet : Uniform (fun n (x : (Fin n → α n) × Fin n) => x.1 x.2) where
  transform := Data.head ∘ (functionGetOption (α := α)).transform
  charge := _
  routine := (functionGetOption (α := α)).routine.comp (Routine.select true)
  correct n x := by
    simp only [Function.comp_apply,(functionGetOption (α := α)).correct,enc_some,Data.head]

def vectorMap {f : ∀ n, Fin n × α n → β n} (R : Uniform f) :
    Uniform (fun n (x : Universe n × α n) => fun v => f n (v,x.2)) where
  transform := (universeList.onFst.comp R.map).transform
  charge := (universeList.onFst.comp R.map).charge
  routine := (universeList.onFst.comp R.map).routine
  correct n x := by
    rw [(universeList.onFst.comp R.map).correct]
    simp only [Function.comp_apply,enc_function,List.ofFn_eq_map]

end Uniform
end ThreeMachine.StackCompiler

end

end OAI