import OAI.Combinatorics.EditDistance.Model

namespace OAI

/-!
# Finite scalar and absolutely summable cut decompositions
-/

namespace EditCuts
open scoped BigOperators
open Finset

lemma top_clipping_distance (a b x y : ℝ) (hba : b < a)
    (hx : x = a ∨ x ≤ b) (hy : y = a ∨ y ≤ b) :
    |x - y| = |min x b - min y b| +
      (a - b) * |(if x = a then (1 : ℝ) else 0) - (if y = a then (1 : ℝ) else 0)| := by
  rcases hx with hx | hx <;> rcases hy with hy | hy
  · subst x; subst y; simp
  · subst x
    have hya : y < a := hy.trans_lt hba
    simp [min_eq_right hba.le, min_eq_left hy, hya.ne,
      abs_of_nonneg (sub_nonneg.mpr hya.le), abs_of_nonneg (sub_nonneg.mpr hy)]
  · subst y
    have hxa : x < a := hx.trans_lt hba
    simp [min_eq_right hba.le, min_eq_left hx, hxa.ne,
      abs_of_nonpos (sub_nonpos.mpr hxa.le), abs_of_nonpos (sub_nonpos.mpr hx)]
  · have hxa : x < a := hx.trans_lt hba
    have hya : y < a := hy.trans_lt hba
    simp [min_eq_left hx, min_eq_left hy, hxa.ne, hya.ne]

section Finite
variable {X : Type*} [Fintype X] [DecidableEq X]

def cut (A : Finset X) (x : X) : ℝ := if x ∈ A then 1 else 0

theorem scalar_decomposition_aux (s : Finset ℝ) :
    ∀ (f : X → ℝ), (∀ x, f x ∈ s) →
      ∃ w : Finset X → ℝ, (∀ A, 0 ≤ w A) ∧
        ∀ x y, |f x - f y| = ∑ A : Finset X, w A * |cut A x - cut A y| := by
  classical
  induction s using Finset.induction_on_max with
  | empty =>
    intro f hf
    refine ⟨fun _ => 0, fun _ => le_rfl, ?_⟩
    intro x
    simpa using hf x
  | insert a s hmax ih =>
    intro f hf
    by_cases hse : s = ∅
    · have hfconst (x : X) : f x = a := by simpa [hse] using hf x
      refine ⟨fun _ => 0, fun _ => le_rfl, ?_⟩
      intro x y
      simp [hfconst]
    have hsn : s.Nonempty := nonempty_iff_ne_empty.mpr hse
    let b : ℝ := s.max' hsn
    have hb : b ∈ s := max'_mem s hsn
    have hba : b < a := hmax b hb
    have hfb (x : X) (hx : f x ≠ a) : f x ≤ b := by
      exact le_max' s (f x) ((mem_insert.mp (hf x)).resolve_left hx)
    let f' : X → ℝ := fun x => min (f x) b
    have hf' (x : X) : f' x ∈ s := by
      by_cases hx : f x = a
      · simpa only [f', hx, min_eq_right hba.le] using hb
      · simpa only [f', min_eq_left (hfb x hx)] using
          ((mem_insert.mp (hf x)).resolve_left hx)
    obtain ⟨w, hw, hwd⟩ := ih f' hf'
    let A : Finset X := univ.filter (fun x => f x = a)
    have hcut (x : X) : cut A x = if f x = a then 1 else 0 := by simp [cut, A]
    have hcase (x : X) : f x = a ∨ f x ≤ b := by
      by_cases hx : f x = a
      · exact Or.inl hx
      · exact Or.inr (hfb x hx)
    have heq (x y : X) : |f x - f y| = |f' x - f' y| +
        (a - b) * |cut A x - cut A y| := by
      simpa only [f', hcut] using top_clipping_distance a b (f x) (f y) hba (hcase x) (hcase y)
    refine ⟨fun B => w B + if B = A then a - b else 0, ?_, ?_⟩
    · intro B
      apply add_nonneg (hw B)
      split_ifs
      · exact sub_nonneg.mpr hba.le
      · exact le_rfl
    · intro x y
      rw [heq, hwd]
      simp only [add_mul, sum_add_distrib, ite_mul, zero_mul, sum_ite_eq', mem_univ, ite_true]

theorem scalar_decomposition (f : X → ℝ) :
    ∃ w : Finset X → ℝ, (∀ A, 0 ≤ w A) ∧
      ∀ x y, |f x - f y| = ∑ A : Finset X, w A * |cut A x - cut A y| :=
  scalar_decomposition_aux (univ.image f) f (fun x => mem_image.mpr ⟨x, mem_univ x, rfl⟩)

end Finite
end EditCuts

namespace EditCuts
open scoped BigOperators
open Finset

abbrev RealL1 := lp (fun _ : ℕ => ℝ) 1

lemma l1_norm (f : RealL1) : ‖f‖ = ∑' n, |f n| := by
  simpa using lp.norm_eq_tsum_rpow (by norm_num : 0 < (1 : ENNReal).toReal) f

lemma l1_summable (f : RealL1) : Summable (fun n => |f n|) := by
  simpa using (lp.memℓp f).summable (by norm_num : 0 < (1 : ENNReal).toReal)

lemma l1_norm_sub (f g : RealL1) : ‖f - g‖ = ∑' n, |f n - g n| :=
  l1_norm (f - g)

section Finite
variable {X : Type*} [Fintype X] [DecidableEq X]

omit [Fintype X] in
lemma cut_empty (x : X) : cut ∅ x = 0 := by simp [cut]
lemma cut_univ (x : X) : cut univ x = 1 := by simp [cut]

theorem scalar_decomposition_nontrivial (f : X → ℝ) :
    ∃ w : Finset X → ℝ, (∀ A, 0 ≤ w A) ∧ w ∅ = 0 ∧ w univ = 0 ∧
      ∀ x y, |f x - f y| = ∑ A : Finset X, w A * |cut A x - cut A y| := by
  classical
  obtain ⟨w, hw, hd⟩ := scalar_decomposition f
  refine ⟨fun A => if A = ∅ ∨ A = univ then 0 else w A, ?_, by simp, by simp, ?_⟩
  · intro A
    dsimp only
    split_ifs <;> simp_all
  · intro x y
    rw [hd]
    apply sum_congr rfl
    intro A _
    by_cases hac : A = ∅ ∨ A = univ
    · rcases hac with rfl | rfl <;> simp [cut_empty, cut_univ]
    · simp [hac]

lemma weight_le_distance (f : X → ℝ) (w : Finset X → ℝ)
    (hw : ∀ A, 0 ≤ w A)
    (hd : ∀ x y, |f x - f y| = ∑ A : Finset X, w A * |cut A x - cut A y|)
    (A : Finset X) (x y : X) (hx : x ∈ A) (hy : y ∉ A) :
    w A ≤ |f x - f y| := by
  rw [hd]
  calc
    w A = w A * |cut A x - cut A y| := by simp [cut, hx, hy]
    _ ≤ _ := single_le_sum (fun B _ => mul_nonneg (hw B) (abs_nonneg (cut B x - cut B y))) (mem_univ A)

theorem l1_decomposition (H : X → RealL1) :
    ∃ c : Finset X → ℝ, (∀ A, 0 ≤ c A) ∧ c ∅ = 0 ∧ c univ = 0 ∧
      ∀ x y, ‖H x - H y‖ = ∑ A : Finset X, c A * |cut A x - cut A y| := by
  classical
  choose w hw he hu hd using fun n => scalar_decomposition_nontrivial (fun x => H x n)
  have hs (A : Finset X) : Summable (fun n => w n A) := by
    by_cases ha : A = ∅ ∨ A = univ
    · rcases ha with rfl | rfl <;> simpa only [he, hu] using (summable_zero : Summable (fun _ : ℕ => (0 : ℝ)))
    obtain ⟨x, hx⟩ := nonempty_iff_ne_empty.mpr (not_or.mp ha).1
    obtain ⟨y, hy⟩ : ∃ y, y ∉ A := by
      by_contra! hn
      exact (not_or.mp ha).2 (eq_univ_iff_forall.mpr hn)
    exact Summable.of_nonneg_of_le (fun n => hw n A)
      (fun n => weight_le_distance _ _ (hw n) (hd n) A x y hx hy)
      (l1_summable (H x - H y))
  refine ⟨fun A => ∑' n, w n A, fun A => tsum_nonneg (fun n => hw n A),
    by simp [he], by simp [hu], ?_⟩
  intro x y
  rw [l1_norm_sub]
  simp_rw [hd]
  rw [Summable.tsum_finsetSum]
  · apply sum_congr rfl
    intro A _
    exact (hs A).tsum_mul_right _
  · intro A _
    exact (hs A).mul_right _

end Finite
end EditCuts

end OAI