import OAI.Combinatorics.CliqueFree.Optimizer
import OAI.Combinatorics.CliqueFree.SparseMultipliers

namespace OAI

noncomputable section

open scoped BigOperators
open Finset

attribute [local instance] Classical.propDecidable

namespace CliqueFreeIndependence.WeightedGraph
open Lottery
universe u
variable {V : Type u} [Fintype V]

lemma edgeForm_smul_left (G : SimpleGraph V) (a b : V → ℝ) (t : ℝ) :
    edgeForm G (fun v ↦ t*a v) b = t*edgeForm G a b := by
  unfold edgeForm
  simp only [mul_sum,mul_ite,mul_zero]
  apply sum_congr rfl
  intro u _
  apply sum_congr rfl
  intro v _
  split_ifs <;> ring

lemma edgeForm_smul_right (G : SimpleGraph V) (a b : V → ℝ) (t : ℝ) :
    edgeForm G a (fun v ↦ t*b v) = t*edgeForm G a b := by
  rw [edgeForm_symm,edgeForm_smul_left,edgeForm_symm G b a]

lemma edgeMass_lin_sub (G : SimpleGraph V) (a b : V → ℝ) (k : ℝ) :
    edgeMass G (fun v ↦ k*a v-b v) =
      k^2*edgeMass G a + edgeMass G b - k*edgeForm G a b := by
  have he : (fun v ↦ k*a v-b v) = (fun v ↦ k*a v)+(fun v ↦ (-1)*b v) := by
    ext v; simp; ring
  rw [he,edgeMass_add,edgeMass_smul,edgeMass_smul,edgeForm_smul_left,edgeForm_smul_right]
  ring

lemma edgeForm_restrict (G : SimpleGraph V) (w : V → ℝ) (S D : Finset V) :
    edgeForm G (restrict S w) (restrict D w) = crossMass G w S D := by
  classical
  unfold edgeForm crossMass restrict
  calc
    _ = ∑ u, if u ∈ S then ∑ v, if v ∈ D then (if G.Adj u v then w u*w v else 0) else 0 else 0 := by
      apply sum_congr rfl
      intro u _
      by_cases hu : u ∈ S
      · simp only [hu,ite_true]
        apply sum_congr rfl
        intro v _
        by_cases hv : v ∈ D <;> simp [hv]
      · simp [hu]
    _ = _ := by
      rw [← sum_filter]
      simp only [filter_mem_eq_inter,univ_inter]
      apply sum_congr rfl
      intro u hu
      rw [← sum_filter]
      simp

lemma expected_weight (w : V → ℝ) (L : Law (V → ℝ)) (S : Finset V)
    (hmean : ∀ v, expect L (fun m ↦ m v) = if v ∈ S then 1 else 0) :
    expect L (fun m ↦ ∑ v, w v*m v) = mass w S := by
  classical
  rw [expect_sum]
  simp_rw [Lottery.expect_mul,hmean,mul_ite,mul_one,mul_zero]
  rw [← sum_filter]
  simp [mass]

lemma expected_edgeForm (G : SimpleGraph V) (w : V → ℝ) (L : Law (V → ℝ)) (S D : Finset V)
    (hmean : ∀ v, expect L (fun m ↦ m v) = if v ∈ S then 1 else 0) :
    expect L (fun m ↦ edgeForm G (fun v ↦ w v*m v) (restrict D w)) = crossMass G w S D := by
  classical
  rw [← edgeForm_restrict]
  simp only [edgeForm_neighbor]
  rw [expect_sum]
  apply sum_congr rfl
  intro u _
  have hf : (fun m : V → ℝ ↦ w u*m u*neighborMass G (restrict D w) u) =
      (fun m ↦ (w u*neighborMass G (restrict D w) u)*m u) := by ext m; ring
  rw [hf,Lottery.expect_mul,hmean]
  by_cases hu : u ∈ S <;> simp [restrict,hu]

lemma vertex_divergence_upper {w y L : ℝ} (hw : 0 < w) (hy : 0 ≤ y) (hL : y ≤ L) :
    (w*(1+y))*Real.log ((w*(1+y))/w) - w*(1+y) + w ≤ w*y*Real.log (1+L) := by
  have hy1 : 0 < 1+y := by linarith
  have hL1 : 0 < 1+L := hy1.trans_le (by linarith)
  have hlog := Real.log_le_sub_one_of_pos hy1
  have hmono := Real.log_le_log hy1 (by linarith : 1+y ≤ 1+L)
  have hlo : w*y*Real.log (1+y) ≤ w*y*Real.log (1+L) :=
    mul_le_mul_of_nonneg_left hmono (mul_nonneg hw.le hy)
  have hcancel : w*(1+y)/w = 1+y := by field_simp
  rw [hcancel]
  nlinarith [mul_le_mul_of_nonneg_left hlog hw.le]

lemma variational_cross_lottery (G : SimpleGraph V) {w : V → ℝ} (hw : IsOptimizer G w)
    (S D : Finset V) (hSD : Disjoint S D) (L : Law (V → ℝ)) (hp : IsProb L)
    {b k ε : ℝ} (hk : 0 ≤ k) (hb : BoundedOn L S b)
    (hm : ∀ v, expect L (fun m ↦ m v) = if v ∈ S then 1 else 0)
    (he : expectedEdges G w L ≤ ε*(mass w S)^2) :
    k*crossMass G w S D ≤ k^2*ε*(mass w S)^2 + (mass w D)^2/2 + mass w D +
      k*Real.log (1+k*b)*mass w S := by
  classical
  have hwpos := fun v ↦ (optimizer_stationary hw v).1
  have hw0 := fun v ↦ (hwpos v).le
  let cost (m : V → ℝ) : ℝ :=
    k*Real.log (1+k*b)*(∑ v, w v*m v) + mass w D +
      (k^2*edgeMass G (fun v ↦ w v*m v) + edgeMass G (restrict D w) -
        k*edgeForm G (fun v ↦ w v*m v) (restrict D w))
  have hcost (z : ℝ × (V → ℝ)) (hz : z ∈ L) : 0 ≤ cost z.2 := by
    let m := z.2
    have hm0 := fun v ↦ (hb z hz).1 v |>.1
    have hmb := fun v ↦ (hb z hz).1 v |>.2
    have hmD (v : V) (hv : v ∈ D) : m v = 0 :=
      (hb z hz).2 v (disjoint_left.1 hSD · hv)
    let q : V → ℝ := fun v ↦ if v ∈ D then 0 else w v*(1+k*m v)
    have hq (v : V) : 0 ≤ q v := by
      dsimp [q]
      split_ifs
      · exact le_rfl
      · exact mul_nonneg (hw0 v) (by nlinarith [mul_nonneg hk (hm0 v)])
    obtain ⟨hdiv,heq⟩ := optimizer_divergence hw q hq
    rw [heq] at hdiv
    have hve (v : V) : q v*Real.log (q v/w v)-q v+w v ≤
        k*Real.log (1+k*b)*(w v*m v) + if v ∈ D then w v else 0 := by
      by_cases hv : v ∈ D
      · simp [q,hv,hmD v hv]
      · have hh := vertex_divergence_upper (hwpos v) (mul_nonneg hk (hm0 v))
          (mul_le_mul_of_nonneg_left (hmb v) hk)
        dsimp [q]
        rw [ite_eq_right hv,ite_eq_right hv]
        nlinarith only [hh]
    have hD : (∑ v, if v ∈ D then w v else 0) = mass w D := by
      rw [← sum_filter]; simp [mass]
    have hvs : (∑ v, (q v*Real.log (q v/w v)-q v+w v)) ≤
        k*Real.log (1+k*b)*(∑ v, w v*m v) + mass w D := by
      calc
        _ ≤ ∑ v, (k*Real.log (1+k*b)*(w v*m v) + if v ∈ D then w v else 0) :=
          sum_le_sum fun v _ ↦ hve v
        _ = _ := by rw [sum_add_distrib,← mul_sum,hD]
    have hqsub : q-w = fun v ↦ k*(w v*m v)-restrict D w v := by
      ext v
      by_cases hv : v ∈ D <;> simp [q,restrict,hv,hmD v,Pi.sub_apply]
      ring
    rw [hqsub,edgeMass_lin_sub] at hdiv
    dsimp [cost,m]
    linarith only [hdiv,hvs]
  have havg : 0 ≤ expect L cost := by
    have hh := expect_mono hp.1 (f := fun _ ↦ 0) (g := cost) (fun z hz ↦ hcost z hz)
    simpa [Lottery.expect_const] using hh
  have hec : expect L cost =
      k*Real.log (1+k*b)*mass w S + mass w D +
        (k^2*expectedEdges G w L + edgeMass G (restrict D w) - k*crossMass G w S D) := by
    have hsub (a b : (V → ℝ) → ℝ) : expect L (fun m ↦ a m-b m) = expect L a-expect L b := by
      have hf : (fun m ↦ a m-b m) = (fun m ↦ a m+(-1)*b m) := by ext m; ring
      rw [hf,expect_add,Lottery.expect_mul]; ring
    dsimp [cost]
    rw [expect_add,expect_add,hsub,expect_add,Lottery.expect_mul,expected_weight w L S hm,
      Lottery.expect_const,hp.2,mul_one,Lottery.expect_mul,Lottery.expect_const,hp.2,mul_one,Lottery.expect_mul,
      expected_edgeForm G w L S D hm]
    rfl
  rw [hec] at havg
  have hDedge : edgeMass G (restrict D w) ≤ (mass w D)^2/2 := by
    rw [edgeMass_restrict]
    exact div_le_div_of_nonneg_right (by simpa [sq] using crossMass_le_product G hw0 D D) (by norm_num)
  have hmult := mul_le_mul_of_nonneg_left he (sq_nonneg k)
  nlinarith only [havg,hDedge,hmult]

end CliqueFreeIndependence.WeightedGraph

end

end OAI