import OAI.Computability.MatchingCount.BinaryParser

namespace OAI

section

namespace BinaryMatching.Algorithm
noncomputable section
open Finset

def Piece.evalReal (p : Piece) (t : ℝ) : ℝ := (p.slope:ℝ)*t+(p.constant:ℝ)

def selectedReal (k : ℕ) (t : ℝ) : Piece := by
  classical
  exact ((pieces k).argmin (fun p => p.evalReal t)).getD ⟨k,0⟩

def psiReal (k : ℕ) (t : ℝ) : ℝ := (selectedReal k t).evalReal t

def dyadic (j : ℕ) : ℝ := (2:ℝ)⁻¹^j

lemma pieces_nonempty (k : ℕ) : pieces k ≠ [] := by simp [pieces]

lemma selectedPiece_mem_argmin (k : ℕ) (t : ℚ) :
    selectedPiece k t ∈ (pieces k).argmin (fun p => p.eval t) := by
  unfold selectedPiece
  cases he : (pieces k).argmin (fun p => p.eval t) with
  | none => exact (pieces_nonempty k (List.argmin_eq_none.mp he)).elim
  | some p => simp

lemma selectedReal_mem_argmin (k : ℕ) (t : ℝ) :
    selectedReal k t ∈ (pieces k).argmin (fun p => p.evalReal t) := by
  classical
  unfold selectedReal
  cases he : (pieces k).argmin (fun p => p.evalReal t) with
  | none => exact (pieces_nonempty k (List.argmin_eq_none.mp he)).elim
  | some p => simp

lemma psiReal_le_piece (k : ℕ) (t : ℝ) (p : Piece) (hp : p∈pieces k) :
    psiReal k t ≤ p.evalReal t :=
  List.le_of_mem_argmin hp (selectedReal_mem_argmin k t)

lemma le_psiReal (k : ℕ) (t b : ℝ) (h : ∀ p∈pieces k,b≤p.evalReal t) :
    b ≤ psiReal k t := h _ (List.argmin_mem (selectedReal_mem_argmin k t))

lemma realPsi_cast (k : ℕ) (t : ℚ) : psiReal k (t:ℝ)=(psi k t:ℝ) := by
  have cast_eval (p : Piece) : p.evalReal (t:ℝ)=(p.eval t:ℝ) := by
    simp [Piece.eval,Piece.evalReal]
  apply le_antisymm
  · have h := psiReal_le_piece k (t:ℝ) _ (List.argmin_mem (selectedPiece_mem_argmin k t))
    simpa only [cast_eval,psi] using h
  · apply le_psiReal
    intro p hp
    rw [cast_eval]
    exact_mod_cast (List.le_of_mem_argmin hp (selectedPiece_mem_argmin k t))

lemma psiReal_concave (k : ℕ) : ConcaveOn ℝ Set.univ (psiReal k) := by
  refine ⟨convex_univ,?_⟩
  intro x _ y _ a b ha hb hab
  apply le_psiReal
  intro p hp
  have hx := psiReal_le_piece k x p hp
  have hy := psiReal_le_piece k y p hp
  simp only [smul_eq_mul]
  calc
    a*psiReal k x+b*psiReal k y ≤ a*p.evalReal x+b*p.evalReal y := by gcongr
    _ = p.evalReal (a*x+b*y) := by
      simp only [Piece.evalReal]
      have hh := congrArg (fun t => t*(p.constant:ℝ)) hab
      nlinarith [hh]

lemma mem_pieces (k : ℕ) (p : Piece) :
    p∈pieces k ↔ p=⟨k,0⟩ ∨ ∃ j<k,p=⟨(j:ℤ)-1,(2:ℚ)⁻¹^j⟩ := by
  simp only [pieces,List.mem_append,List.mem_map,List.mem_range,List.mem_singleton]
  aesop

lemma first_mem_pieces (k : ℕ) : (⟨k,0⟩:Piece)∈pieces k := (mem_pieces k _).2 (Or.inl rfl)
lemma chord_mem_pieces (k j : ℕ) (hj : j<k) :
    (⟨(j:ℤ)-1,(2:ℚ)⁻¹^j⟩:Piece)∈pieces k := (mem_pieces k _).2 (Or.inr ⟨j,hj,rfl⟩)

lemma chord_eval (j : ℕ) (t : ℝ) :
    (⟨(j:ℤ)-1,(2:ℚ)⁻¹^j⟩:Piece).evalReal t=((j:ℝ)-1)*t+dyadic j := by
  simp [Piece.evalReal,dyadic]

lemma first_eval (k : ℕ) (t : ℝ) : (⟨k,0⟩:Piece).evalReal t=(k:ℝ)*t := by
  simp [Piece.evalReal]

lemma dyadic_pos (j : ℕ) : 0<dyadic j := by unfold dyadic; positivity
lemma dyadic_nonneg (j : ℕ) : 0≤dyadic j := (dyadic_pos j).le
lemma dyadic_succ (j : ℕ) : dyadic (j+1)=dyadic j/2 := by simp [dyadic,pow_succ,div_eq_mul_inv]
lemma dyadic_zero : dyadic 0=1 := by simp [dyadic]
lemma dyadic_mul_pow (j : ℕ) : dyadic j*(2:ℝ)^j=1 := by
  rw [dyadic,←mul_pow]; norm_num

lemma dyadic_scale (j l : ℕ) (h : l≤j) : dyadic l=(2:ℝ)^(j-l)*dyadic j := by
  have hj : j=l+(j-l) := by omega
  conv_rhs => rw [hj,dyadic,pow_add]
  rw [Nat.add_sub_cancel_left]
  change (2:ℝ)⁻¹^l=(2:ℝ)^(j-l)*((2:ℝ)⁻¹^l*(2:ℝ)⁻¹^(j-l))
  calc
    _ = (2:ℝ)⁻¹^l*1 := (mul_one _).symm
    _ = _ := by rw [←dyadic_mul_pow (j-l)]; unfold dyadic; ring

lemma chord_above_knot (l j : ℕ) :
    (j:ℝ)*dyadic j ≤ ((l:ℝ)-1)*dyadic j+dyadic l := by
  rcases lt_trichotomy l j with h|h|h
  · have hp : 1+(j-l:ℕ) ≤ (2:ℕ)^(j-l) := by
      have hh := one_add_mul_le_pow (show (-2:ℝ)≤1 by norm_num) (j-l)
      norm_num at hh
      exact_mod_cast hh
    have hpR : (1:ℝ)+(j:ℝ)-(l:ℝ) ≤ (2:ℝ)^(j-l) := by
      have := Nat.cast_le (α:=ℝ).mpr hp
      push_cast [Nat.cast_sub h.le] at this
      linarith
    rw [dyadic_scale j l h.le]
    nlinarith [mul_le_mul_of_nonneg_right hpR (dyadic_nonneg j)]
  · subst l; ring_nf; rfl
  · have hh : (j:ℝ)+1≤l := by exact_mod_cast h
    nlinarith [dyadic_nonneg j,dyadic_nonneg l]

lemma psiReal_knot (k j : ℕ) (hj : j≤k) : psiReal k (dyadic j)=(j:ℝ)*dyadic j := by
  apply le_antisymm
  · rcases lt_or_eq_of_le hj with h|h
    · have hh := psiReal_le_piece k (dyadic j) _ (chord_mem_pieces k j h)
      rw [chord_eval] at hh
      nlinarith
    · subst j
      simpa only [first_eval] using psiReal_le_piece k (dyadic k) _ (first_mem_pieces k)
  · apply le_psiReal
    intro p hp
    rcases (mem_pieces k p).1 hp with rfl|⟨l,_,rfl⟩
    · rw [first_eval]
      exact mul_le_mul_of_nonneg_right (by exact_mod_cast hj) (dyadic_nonneg j)
    · rw [chord_eval]; exact chord_above_knot l j

lemma psiReal_zero (k : ℕ) : psiReal k 0=0 := by
  apply le_antisymm
  · simpa only [first_eval,mul_zero] using psiReal_le_piece k 0 _ (first_mem_pieces k)
  · apply le_psiReal
    intro p hp
    rcases (mem_pieces k p).1 hp with rfl|⟨j,_,rfl⟩
    · simp [first_eval]
    · simpa only [chord_eval,mul_zero,zero_add] using dyadic_nonneg j

end
end BinaryMatching.Algorithm
end

end OAI