import OAI.Combinatorics.CliqueFree.LocalWalk

namespace OAI

noncomputable section

open scoped BigOperators
open Finset

attribute [local instance] Classical.propDecidable

namespace CliqueFreeIndependence.WeightedGraph

universe u v

variable {V : Type u} [Fintype V]

attribute [local instance 10000] edgeStateDecEq

namespace LocalWalk
open FiniteEntropy FiniteKernel
variable {G : SimpleGraph V} {w : V → ℝ}

noncomputable def liftSet (u : V) (A : Finset V) : Finset (EdgeState G) :=
  univ.filter (fun e ↦ e.src = u ∧ e.dst ∈ A)

@[simp] lemma mem_liftSet (u : V) (A : Finset V) (e : EdgeState G) :
    e ∈ liftSet (G := G) u A ↔ e.src = u ∧ e.dst ∈ A := by simp [liftSet]

lemma liftSet_subset_fiber (u : V) (A : Finset V) : liftSet (G := G) u A ⊆ fiber G u := by
  intro e he
  exact (mem_fiber G e u).2 ((mem_liftSet u A e).1 he).1

lemma sum_liftSet (u : V) (A : Finset V) (f : V → ℝ) :
    (∑ e ∈ liftSet (G := G) u A, f e.dst) = ∑ v ∈ A ∩ neighbors G u, f v := by
  rw [liftSet, sum_filter]
  have he : (∑ e : EdgeState G, if e.src = u ∧ e.dst ∈ A then f e.dst else 0) =
      ∑ e : EdgeState G, if e.src = u then (if e.dst ∈ A then f e.dst else 0) else 0 := by
    apply sum_congr rfl
    intro e _
    by_cases hs : e.src = u <;> by_cases hd : e.dst ∈ A <;> simp [hs, hd]
  rw [he, EdgeState.sum_fiber u (fun v ↦ if v ∈ A then f v else 0), ← sum_filter]
  congr 1
  ext v
  simp [and_comm]

lemma lazy_neighbor_density (hw : ∀ u, 0 < w u) {x : ℝ} (hx : 0 < x)
    (hc : ∀ u v, G.Adj u v → 1 / x ≤ commonMass G w u v)
    (e f : EdgeState G) (h : e.dst ≠ f.dst) :
    lazy (transition G w) e f ≤ if G.Adj e.dst f.dst then x * w f.dst else 0 := by
  have hef : e ≠ f := fun he ↦ h (congrArg EdgeState.dst he)
  simp only [lazy, hef, ite_false, zero_add]
  have hp := transition_density hw hx hc e f
  have hc0 : ∀ u v, G.Adj u v → 0 < commonMass G w u v :=
    fun u v huv ↦ (one_div_pos.2 hx).trans_le (hc u v huv)
  have hn := (transition_stochastic hw hc0 e).1 f
  by_cases hadj : G.Adj e.dst f.dst
  · rw [ite_eq_left hadj]
    change transition G w e f ≤ x * w f.dst at hp
    linarith
  · simp [transition, hadj]

lemma liftSet_adj_mass_le (hw : ∀ u, 0 ≤ w u) (u y : V) (A : Finset V) :
    (∑ z ∈ liftSet (G := G) u A, if G.Adj z.dst y then w z.dst else 0) ≤
      mass w (A ∩ neighbors G y) := by
  rw [sum_liftSet u A (fun z ↦ if G.Adj z y then w z else 0), ← sum_filter]
  have he : (A ∩ neighbors G u).filter (fun z ↦ G.Adj z y) =
      (A ∩ neighbors G y) ∩ neighbors G u := by
    ext z
    simp [G.adj_comm z y, and_assoc, and_comm]
  rw [he]
  exact mass_mono hw inter_subset_left

lemma incoming_good_le (hw : ∀ u, 0 < w u) {x : ℝ} (hx : 0 < x)
    (hc : ∀ u v, G.Adj u v → 1 / x ≤ commonMass G w u v)
    {t : ℝ} (ht : 0 ≤ t) (n : ℕ) (e : EdgeState G) (A : Finset V) :
    (∑ y ∈ (liftSet (G := G) e.src (enlarge G w t A))ᶜ,
      ∑ z ∈ liftSet (G := G) e.src A,
        smoothed (transition G w) n e z * lazy (transition G w) z y) ≤
      x ^ 2 * t * neighborMass G w e.src := by
  have hc0 : ∀ u v, G.Adj u v → 0 < commonMass G w u v :=
    fun u v huv ↦ (one_div_pos.2 hx).trans_le (hc u v huv)
  have hP := transition_stochastic hw hc0
  have hQ := stochastic_lazy hP
  have hpt := preserves_lazy (label := EdgeState.src) (transition_fixed_src (G := G) (w := w))
  have hrow (y : EdgeState G) (hy : y ∈ (liftSet (G := G) e.src (enlarge G w t A))ᶜ) :
      (∑ z ∈ liftSet (G := G) e.src A,
        smoothed (transition G w) n e z * lazy (transition G w) z y) ≤
        if y.src = e.src then x ^ 2 * t * w y.dst else 0 := by
    by_cases hsrc : y.src = e.src
    · rw [ite_eq_left hsrc]
      have hyout : y.dst ∉ enlarge G w t A := by
        intro h
        exact (mem_compl.1 hy) ((mem_liftSet _ _ _).2 ⟨hsrc, h⟩)
      have hymass := (not_mem_enlarge G w t A hyout).2.le
      calc
        _ ≤ ∑ z ∈ liftSet (G := G) e.src A,
            (if G.Adj z.dst y.dst then w z.dst else 0) * (x ^ 2 * w y.dst) := by
          apply sum_le_sum
          intro z hz
          have hzA := ((mem_liftSet _ _ _).1 hz).2
          have hzy : z.dst ≠ y.dst := by
            intro h
            apply hyout
            exact subset_enlarge G w t A (h ▸ hzA)
          have h1 := smoothed_density hw hx hc n e z
          have h2 := lazy_neighbor_density hw hx hc z y hzy
          change smoothed (transition G w) n e z ≤ x * w z.dst at h1
          have hm := mul_le_mul h1 h2 ((hQ z).1 y) (mul_pos hx (hw z.dst)).le
          by_cases hadj : G.Adj z.dst y.dst
          · simpa only [ite_eq_left hadj] using hm.trans_eq (by rw [ite_eq_left hadj]; ring)
          · simpa only [ite_eq_right hadj, mul_zero, zero_mul] using hm
        _ = (∑ z ∈ liftSet (G := G) e.src A,
            if G.Adj z.dst y.dst then w z.dst else 0) * (x ^ 2 * w y.dst) :=
          (sum_mul _ _ _).symm
        _ ≤ mass w (A ∩ neighbors G y.dst) * (x ^ 2 * w y.dst) :=
          mul_le_mul_of_nonneg_right (liftSet_adj_mass_le (fun u ↦ (hw u).le) _ _ _)
            (mul_nonneg (sq_nonneg x) (hw y.dst).le)
        _ ≤ t * (x ^ 2 * w y.dst) := mul_le_mul_of_nonneg_right hymass
          (mul_nonneg (sq_nonneg x) (hw y.dst).le)
        _ = _ := by ring
    · rw [ite_eq_right hsrc]
      apply le_of_eq
      apply sum_eq_zero
      intro z hz
      have hzs := ((mem_liftSet _ _ _).1 hz).1
      rw [hpt z y (fun h ↦ hsrc (h.symm.trans hzs)), mul_zero]
  calc
    _ ≤ ∑ y ∈ (liftSet (G := G) e.src (enlarge G w t A))ᶜ,
        if y.src = e.src then x ^ 2 * t * w y.dst else 0 := sum_le_sum hrow
    _ ≤ ∑ y : EdgeState G, if y.src = e.src then x ^ 2 * t * w y.dst else 0 := by
      apply sum_le_univ_sum_of_nonneg
      intro y
      split_ifs
      · exact mul_nonneg (mul_nonneg (sq_nonneg x) ht) (hw _).le
      · exact le_rfl
    _ = _ := by
      rw [EdgeState.sum_fiber e.src (fun y ↦ x ^ 2 * t * w y), ← mul_sum]
      rfl

lemma reach_leakage (hw : ∀ u, 0 < w u) {x : ℝ} (hx : 0 < x)
    (hc : ∀ u v, G.Adj u v → 1 / x ≤ commonMass G w u v)
    {L t : ℝ} (hL : ∀ u, neighborMass G w u ≤ L) (ht : 0 ≤ t)
    (n : ℕ) (e : EdgeState G) :
    rowMass (smoothed (transition G w) n) e
      (liftSet (G := G) e.src (reach G w t e.dst n))ᶜ ≤ n * (x ^ 2 * t * L) := by
  have hc0 : ∀ u v, G.Adj u v → 0 < commonMass G w u v :=
    fun u v huv ↦ (one_div_pos.2 hx).trans_le (hc u v huv)
  have hP := transition_stochastic hw hc0
  induction n with
  | zero =>
    simp only [smoothed_zero, Nat.cast_zero, zero_mul, reach]
    apply le_of_eq
    apply sum_eq_zero
    intro f hf
    have hf' := mem_compl.1 hf
    by_cases hs : e.src = f.src
    · have ha : ¬G.Adj e.dst f.dst := by
        intro h
        exact hf' ((mem_liftSet _ _ _).2 ⟨hs.symm, (mem_neighbors G _ _).2 h⟩)
      simp [transition, hs, ha]
    · exact transition_fixed_src e f hs
  | succ n ih =>
    rw [smoothed_succ_right]
    have h := leakage_mul_le (stochastic_smoothed hP n) (stochastic_lazy hP) e
      (liftSet (G := G) e.src (reach G w t e.dst n))
      (liftSet (G := G) e.src (reach G w t e.dst (n+1)))
    have hinc := incoming_good_le hw hx hc ht n e (reach G w t e.dst n)
    have hmass := mul_le_mul_of_nonneg_left (hL e.src) (mul_nonneg (sq_nonneg x) ht)
    simp only [reach] at h
    simp only [Nat.cast_add, Nat.cast_one]
    change rowMass (smoothed (transition G w) n * lazy (transition G w)) e
      (liftSet (G := G) e.src (enlarge G w t (reach G w t e.dst n)))ᶜ ≤ _
    calc
      _ ≤ _ := h
      _ ≤ n * (x ^ 2 * t * L) + x ^ 2 * t * L :=
        add_le_add ih (hinc.trans hmass)
      _ = _ := by ring

lemma law_rev (e : EdgeState G) : law G w e.rev = law G w e := by
  simp only [law, EdgeState.src_rev, EdgeState.dst_rev, commonMass_comm G w e.dst e.src]
  ring

lemma law_bad_sum (B : V → Finset V) (hB : ∀ v, B v ⊆ neighbors G v) :
    (∑ e : EdgeState G, if e.src ∈ B e.dst then law G w e else 0) =
      (∑ v, w v * crossMass G w (B v) (neighbors G v)) / normalizer G w := by
  have hr := EdgeState.revEquiv (G := G) |>.sum_comp
    (fun e : EdgeState G ↦ if e.src ∈ B e.dst then law G w e else 0)
  simp only [EdgeState.revEquiv, Equiv.coe_fn_mk, EdgeState.src_rev, EdgeState.dst_rev,
    law_rev] at hr
  rw [← hr]
  unfold law
  rw [EdgeState.sum_eq (fun u v ↦ if v ∈ B u then
    w u * w v * commonMass G w u v / normalizer G w else 0)]
  simp_rw [crossMass_neighbors, mul_sum, sum_div]
  apply sum_congr rfl
  intro v _
  rw [← sum_filter]
  have he : (neighbors G v).filter (fun u ↦ u ∈ B v) = B v :=
    filter_mem_eq_inter.trans (inter_eq_right.2 (hB v))
  rw [he]
  apply sum_congr rfl
  intro u _
  rw [commonMass_comm G w v u]
  ring

lemma law_bad_le [Nonempty (EdgeState G)] (hw : ∀ u, 0 < w u)
    (hc : ∀ u v, G.Adj u v → 0 < commonMass G w u v)
    (B : V → Finset V) (hB : ∀ v, B v ⊆ neighbors G v) {q : ℝ}
    (hb : ∀ v, crossMass G w (B v) (neighbors G v) ≤ q * triangleAt G w v) :
    (∑ e : EdgeState G, if e.src ∈ B e.dst then law G w e else 0) ≤ q := by
  rw [law_bad_sum B hB, div_le_iff₀ (normalizer_pos hw hc)]
  calc
    _ ≤ ∑ v, w v * (q * triangleAt G w v) :=
      sum_le_sum fun v _ ↦ mul_le_mul_of_nonneg_left (hb v) (hw v).le
    _ = q * normalizer G w := by
      rw [normalizer_eq, triangleMass_eq_sum, mul_sum]
      apply sum_congr rfl
      intro v _
      ring

lemma entropy_good_row (hw : ∀ u, 0 < w u) {x : ℝ} (hx : 0 < x)
    (hc : ∀ u v, G.Adj u v → 1 / x ≤ commonMass G w u v)
    (hL : ∀ u, neighborMass G w u ≤ Real.exp x)
    {t : ℝ} (ht : 0 ≤ t) (n : ℕ) (e : EdgeState G) {b : ℝ} (hb : 1 ≤ b)
    (he : e.src ∉ badSet G w (fun v ↦ reach G w t v n) b e.dst) :
    entropy (vertexWeight G w) (smoothed (transition G w) n e) ≤
      Real.log 2 + Real.log b + (n * (x ^ 2 * t * Real.exp x)) * x := by
  have hc0 : ∀ u v, G.Adj u v → 0 < commonMass G w u v :=
    fun u v huv ↦ (one_div_pos.2 hx).trans_le (hc u v huv)
  have hP := transition_stochastic hw hc0
  have hsmall : mass w (reach G w t e.dst n ∩ neighbors G e.src) ≤ b := by
    by_contra! h
    exact he (mem_filter.2 ⟨(mem_neighbors G _ _).2 e.adj.symm, h⟩)
  have h := entropy_supported_concentration (w := vertexWeight G w)
    (fiber G e.src) (liftSet (G := G) e.src (reach G w t e.dst n))
    (liftSet_subset_fiber _ _) (fun f _ ↦ hw f.dst) (stochastic_smoothed hP n e)
    (smoothed_supported n e) hb (Real.exp_pos x)
    (by change (∑ f ∈ liftSet (G := G) e.src (reach G w t e.dst n), w f.dst) ≤ b
        rw [sum_liftSet]; exact hsmall)
    (by rw [fiber_mass]; exact hL _)
  rw [Real.log_exp] at h
  have hl := reach_leakage hw hx hc hL ht n e
  rw [rowMass_compl (stochastic_smoothed hP n)] at hl
  exact h.trans (add_le_add le_rfl (mul_le_mul_of_nonneg_right hl hx.le))

lemma averaged_entropy_bound [Nonempty (EdgeState G)] (hw : ∀ u, 0 < w u)
    {x : ℝ} (hx : 0 < x)
    (hc : ∀ u v, G.Adj u v → 1 / x ≤ commonMass G w u v)
    (hL : ∀ u, neighborMass G w u ≤ Real.exp x)
    {t : ℝ} (ht : 0 ≤ t) (n : ℕ) {b q : ℝ} (hb : 1 ≤ b)
    (hbad : (∑ e : EdgeState G,
      if e.src ∈ badSet G w (fun v ↦ reach G w t v n) b e.dst then law G w e else 0) ≤ q) :
    avgEntropy (law G w) (vertexWeight G w) (smoothed (transition G w) n) ≤
      Real.log 2 + Real.log b + (n * (x ^ 2 * t * Real.exp x)) * x + q * x := by
  have hc0 : ∀ u v, G.Adj u v → 0 < commonMass G w u v :=
    fun u v huv ↦ (one_div_pos.2 hx).trans_le (hc u v huv)
  have hmu := law_isProb hw hc0
  let A := Real.log 2 + Real.log b + (n * (x ^ 2 * t * Real.exp x)) * x
  have hA : 0 ≤ A := by
    dsimp [A]
    have hl2 : 0 ≤ Real.log 2 := Real.log_nonneg (by norm_num)
    have hlb : 0 ≤ Real.log b := Real.log_nonneg hb
    positivity
  have hrow (e : EdgeState G) :
      entropy (vertexWeight G w) (smoothed (transition G w) n e) ≤
        A + if e.src ∈ badSet G w (fun v ↦ reach G w t v n) b e.dst then x else 0 := by
    split_ifs with he
    · exact (entropy_bounds hw hx hc hL n e).2.trans (by linarith)
    · simpa only [add_zero] using entropy_good_row hw hx hc hL ht n e hb he
  calc
    _ ≤ ∑ e, law G w e *
        (A + if e.src ∈ badSet G w (fun v ↦ reach G w t v n) b e.dst then x else 0) :=
      sum_le_sum fun e _ ↦ mul_le_mul_of_nonneg_left (hrow e) (hmu.1 e)
    _ = A + (∑ e : EdgeState G,
        if e.src ∈ badSet G w (fun v ↦ reach G w t v n) b e.dst then law G w e else 0) * x := by
      simp only [mul_add, sum_add_distrib, ← sum_mul, hmu.2, one_mul, mul_ite, mul_zero]
      rw [sum_mul]
      simp only [ite_mul, zero_mul]
    _ ≤ _ := add_le_add le_rfl (mul_le_mul_of_nonneg_right hbad hx.le)

lemma avg_entropy_lower [Nonempty (EdgeState G)] (hw : ∀ u, 0 < w u)
    {x : ℝ} (hx : 0 < x)
    (hc : ∀ u v, G.Adj u v → 1 / x ≤ commonMass G w u v)
    (hL : ∀ u, neighborMass G w u ≤ Real.exp x) (n : ℕ) :
    -Real.log x ≤ avgEntropy (law G w) (vertexWeight G w) (smoothed (transition G w) n) := by
  have hc0 : ∀ u v, G.Adj u v → 0 < commonMass G w u v :=
    fun u v huv ↦ (one_div_pos.2 hx).trans_le (hc u v huv)
  have hmu := law_isProb hw hc0
  calc
    _ = (∑ e, law G w e) * (-Real.log x) := by rw [hmu.2, one_mul]
    _ = ∑ e, law G w e * (-Real.log x) := sum_mul _ _ _
    _ ≤ _ := sum_le_sum fun e _ ↦ mul_le_mul_of_nonneg_left
      (entropy_bounds hw hx hc hL n e).1 (hmu.1 e)

lemma avg_entropy_upper [Nonempty (EdgeState G)] (hw : ∀ u, 0 < w u)
    {C x : ℝ} (hC : 0 ≤ C) (hCross : CrossBound G w C) (hx : 32 ≤ x)
    (hc : ∀ u v, G.Adj u v → 1 / x ≤ commonMass G w u v)
    (hL : ∀ u, neighborMass G w u ≤ Real.exp x)
    (n : ℕ) (hn : (n : ℝ) ≤ 2 * x) :
    avgEntropy (law G w) (vertexWeight G w) (smoothed (transition G w) n) ≤
      entropyConstant C * Real.log x := by
  have hx0 : 0 < x := by linarith
  have hx1 : 1 ≤ x := by linarith
  have hc0 : ∀ u v, G.Adj u v → 0 < commonMass G w u v :=
    fun u v huv ↦ (one_div_pos.2 hx0).trans_le (hc u v huv)
  have hbad := law_bad_le hw hc0
    (badSet G w (fun u ↦ reach G w (Numerical.threshold x) u n) (x ^ 8))
    (badSet_subset G w _ _) (reach_bad_cross G (fun u ↦ (hw u).le) hC hCross hx hL hc hn)
  have hb : (1 : ℝ) ≤ x ^ 8 := one_le_pow₀ hx1
  have h := averaged_entropy_bound hw hx0 hc hL (Numerical.threshold_pos hx0).le n hb hbad
  rw [Real.log_pow] at h
  have hleak : ((n : ℝ) * (x ^ 2 * Numerical.threshold x * Real.exp x)) * x ≤ 1 := by
    rw [Numerical.leakage_factor hx0]
    calc
      _ = (n : ℝ) / x ^ 3 := by field_simp [hx0.ne']
      _ ≤ (2 * x) / x ^ 3 := div_le_div_of_nonneg_right hn (pow_pos hx0 3).le
      _ = 2 / x ^ 2 := by field_simp [hx0.ne']
      _ ≤ 1 := (div_le_iff₀ (pow_pos hx0 2)).2 (by nlinarith)
  have hE := exceptionalConstant_nonneg hC
  have hq : (exceptionalConstant C / x ^ 4) * x ≤ exceptionalConstant C * Real.log x := by
    calc
      _ = exceptionalConstant C / x ^ 3 := by field_simp [hx0.ne']
      _ ≤ exceptionalConstant C := (div_le_iff₀ (pow_pos hx0 3)).2 (by
        simpa only [mul_one] using mul_le_mul_of_nonneg_left (one_le_pow₀ hx1 (n := 3)) hE)
      _ ≤ _ := by nlinarith [(Numerical.log_bounds hx).1]
  have hl2 : Real.log 2 ≤ Real.log x := Real.log_le_log (by norm_num) (by linarith)
  have hl1 := (Numerical.log_bounds hx).1
  unfold entropyConstant
  norm_num only [Nat.cast_ofNat] at h
  linarith

noncomputable def rowDistance (n : ℕ) : ℝ :=
  ∑ e : EdgeState G, law G w e * ∑ f, transition G w e f *
    tv (smoothed (transition G w) n e) (smoothed (transition G w) n f)

/-- The `C`-dependent entropy smoothing bound. -/
lemma exists_smooth_index [Nonempty (EdgeState G)] (hw : ∀ u, 0 < w u)
    {C x : ℝ} (hC : 1 ≤ C) (hCross : CrossBound G w C) (hx : 32 ≤ x)
    (hc : ∀ u v, G.Adj u v → 1 / x ≤ commonMass G w u v)
    (hL : ∀ u, neighborMass G w u ≤ Real.exp x) :
    ∃ j < ⌈x⌉₊,
      avgEntropy (law G w) (vertexWeight G w) (smoothed (transition G w) j) ≤
        entropyConstant C * Real.log x ∧
      rowDistance (G := G) (w := w) j ≤ smoothingConstant C * Real.sqrt (Real.log x / x) := by
  have hx0 : 0 < x := by linarith
  have hC0 : 0 ≤ C := by linarith
  have hc0 : ∀ u v, G.Adj u v → 0 < commonMass G w u v :=
    fun u v huv ↦ (one_div_pos.2 hx0).trans_le (hc u v huv)
  have hmu := law_isProb hw hc0
  have hP := transition_stochastic hw hc0
  have hs := stationary_of_reversible hP (transition_reversible hw hc0)
  have hceil := Numerical.ceil_bounds hx
  have hlow := avg_entropy_lower hw hx0 hc hL 0
  have hupp := avg_entropy_upper hw hC0 hCross hx hc hL ⌈x⌉₊ hceil.2.2
  have hD : avgEntropy (law G w) (vertexWeight G w) (smoothed (transition G w) ⌈x⌉₊) -
      avgEntropy (law G w) (vertexWeight G w) (smoothed (transition G w) 0) ≤
      (entropyConstant C + 1) * Real.log x := by linarith
  obtain ⟨j, hj, hdist⟩ := exists_smoothed_row_distance hmu (fun e ↦ hw e.dst) hP hs hceil.1 hD
  refine ⟨j, hj, ?_, ?_⟩
  · exact (smoothed_entropy_mono hmu (fun e ↦ hw e.dst) hP hs (Nat.le_of_lt hj)).trans hupp
  · have hA : 0 ≤ entropyConstant C + 1 := by
      have := exceptionalConstant_nonneg hC0
      unfold entropyConstant
      linarith
    have hlog : 0 ≤ Real.log x := ((Numerical.log_bounds hx).1.trans' (by norm_num))
    have href : rowDistance (G := G) (w := w) j ^ 2 ≤
        4 * ((entropyConstant C + 1) * Real.log x) / x := by
      exact hdist.trans (div_le_div_of_nonneg_left (by positivity) hx0 hceil.2.1)
    have hf : 0 ≤ Real.log x / x := div_nonneg hlog hx0.le
    have hsq : (smoothingConstant C * Real.sqrt (Real.log x / x)) ^ 2 =
        4 * ((entropyConstant C + 1) * Real.log x) / x := by
      rw [mul_pow, smoothingConstant, mul_pow, Real.sq_sqrt hA, Real.sq_sqrt hf]
      ring
    have hn : 0 ≤ smoothingConstant C * Real.sqrt (Real.log x / x) := by
      unfold smoothingConstant
      positivity
    nlinarith

end LocalWalk

end CliqueFreeIndependence.WeightedGraph

end

end OAI