import OAI.Computability.MatchingCount.RawData

namespace OAI

section

namespace BinaryMatching.StackCode
open Polynomial

lemma argAux_code {α : Type} [Coding α] (r : α → α → Prop) [DecidableRel r]
    (z : Option α×α) :
    (encode (List.argAux r z.1 z.2)).length≤(encode z.1).length+2*(encode z.2).length+1 := by
  rcases z with ⟨o,a⟩
  cases o with
  | none => simp [List.argAux,code_option_none,code_option_some]
  | some b =>
    simp only [List.argAux]
    split_ifs <;> simp only [code_option_some] <;> omega

namespace Poly
variable {α β : Type} [Coding α] [Coding β]

@[fun_prop] theorem argAux [Inhabited α] (r : α → α → Prop) [DecidableRel r]
    (hr : Poly (fun z : α×α => decide (r z.1 z.2))) :
    Poly (fun z : Option α×α => List.argAux r z.1 z.2) := by
  have h : Poly (fun z : Option α×α => if z.1.isSome then
      if decide (r z.2 (z.1.getD default)) then Option.some z.2 else z.1 else Option.some z.2) := by
    apply cond
    · fun_prop
    · fun_prop
    · apply cond
      · exact comp _ (fun z : Option α×α => (z.2,z.1.getD default)) hr (by fun_prop)
      · fun_prop
      · fun_prop
  exact h.congr (fun z => by cases z.1 <;> simp [List.argAux])

theorem listArgAux [Inhabited α] (r : α → α → Prop) [DecidableRel r]
    (hr : Poly (fun z : α×α => decide (r z.1 z.2))) :
    Poly (fun l : List α => l.foldl (List.argAux r) none) := by
  have hf := listFoldAdd (fun z : Option α×α => List.argAux r z.1 z.2)
    (argAux r hr) 1 (by intro z; simpa only [one_mul,Nat.add_assoc] using argAux_code r z)
  exact comp _ (fun l : List α => (l,(none:Option α))) hf (by fun_prop)

@[fun_prop] theorem listArgmin [Inhabited α] [Preorder β] [DecidableLT β]
    (hb : Poly (fun z : β×β => decide (z.1<z.2))) (f : α → β) (hf : Poly f) :
    Poly (List.argmin f) := by
  apply listArgAux (fun a b => f a<f b)
  exact comp _ (fun z : α×α => (f z.1,f z.2)) hb (by fun_prop)

@[fun_prop] theorem listArgmax [Inhabited α] [Preorder β] [DecidableLT β]
    (hb : Poly (fun z : β×β => decide (z.1<z.2))) (f : α → β) (hf : Poly f) :
    Poly (List.argmax f) := by
  apply listArgAux (fun a b => f b<f a)
  exact comp _ (fun z : α×α => (f z.2,f z.1)) hb (by fun_prop)

end Poly

lemma argmin_map_exact {α β γ : Type} [Preorder γ] [DecidableLT γ]
    (l : List α) (f : α → β) (g : β → γ) :
    (l.map f).argmin g=(l.argmin (g ∘ f)).map f := by
  induction l using List.reverseRecOn with
  | nil => rfl
  | append_singleton l a ih =>
    simp only [List.map_append,List.map_singleton,List.argmin_concat,ih]
    cases h : l.argmin (g ∘ f) with
    | none => rfl
    | some b => simp only [Option.map_some,Function.comp_apply]; split_ifs <;> rfl

namespace Poly
variable {α β γ : Type} [Coding α] [Coding β] [Coding γ]

@[fun_prop] theorem listArgminParam [Inhabited α] [Inhabited γ]
    [Preorder β] [DecidableLT β]
    (hb : Poly (fun z : β×β => decide (z.1<z.2))) (f : γ×α → β) (hf : Poly f) :
    Poly (fun z : γ×List α => z.2.argmin (fun a => f (z.1,a))) := by
  have hm : Poly (fun z : γ×List α => z.2.map (fun a => (z.1,a))) :=
    listMapParam (fun z : γ×α => z) identity
  have h : Poly (fun z : γ×List α => ((z.2.map fun a => (z.1,a)).argmin f).map Prod.snd) := by
    apply comp _ _ (optionMap Prod.snd (by fun_prop))
    exact comp _ _ (listArgmin hb f hf) hm
  exact h.congr (fun z => by
    rw [argmin_map_exact]
    simp [Option.map_map,Function.comp_def])

@[fun_prop] theorem listArgmaxParam [Inhabited α] [Inhabited γ]
    [Preorder β] [DecidableLT β]
    (hb : Poly (fun z : β×β => decide (z.1<z.2))) (f : γ×α → β) (hf : Poly f) :
    Poly (fun z : γ×List α => z.2.argmax (fun a => f (z.1,a))) := by
  let : Coding βᵒᵈ := inferInstanceAs (Coding β)
  apply @listArgminParam α βᵒᵈ γ _ _ _ _ _ _ _ _ f hf
  exact comp (fun z : β×β => decide (z.1<z.2)) (fun z : β×β => (z.2,z.1)) hb (by fun_prop)

end Poly
end BinaryMatching.StackCode
end

end OAI