lean/OAI/Dynamics/StandardMap/Entropy/LiftGrid.lean

import OAI.Dynamics.StandardMap.EntropyEndpoint
import OAI.Dynamics.StandardMap.Stable.SmoothRemainder

namespace OAI

section
section
namespace StandardMapEntropy
open MeasureTheory Set Filter
open scoped BigOperators ENNReal Topology

noncomputable def gridIntIndex (Q : ℕ) (hQ : 0<Q) (i : ℤ) : Fin Q :=
  ⟨(i%(Q : ℤ)).toNat,by
    have h0 := Int.emod_nonneg i (show (Q : ℤ)≠0 by omega)
    have h1 := Int.emod_lt_of_pos i (show (0 : ℤ)<Q by omega)
    omega⟩
lemma gridIndex_coe_int (Q : ℕ) (hQ : 0<Q) (y : ℝ) :
    gridIndex Q hQ (y : Circle)=gridIntIndex Q hQ ⌊(Q : ℝ)*y⌋ := by
  have hb : ((gridIndex Q hQ (y : Circle)).val : ℤ)=⌊(Q : ℝ)*y⌋-⌊y⌋*(Q : ℤ) := by
    change (⌊(Q : ℝ)*circleRep (y : Circle)⌋₊ : ℤ)=_
    rw [Int.natCast_floor_eq_floor (mul_nonneg (Nat.cast_nonneg Q) (circleRep_mem (y : Circle)).1),circleRep_coe]
    have he : (Q : ℝ)*Int.fract y=(Q : ℝ)*y-((⌊y⌋*(Q : ℤ) : ℤ) : ℝ) := by
      simp only [Int.fract,Int.cast_mul,Int.cast_natCast]
      ring
    rw [he,Int.floor_sub_intCast]
  have hm : ⌊(Q : ℝ)*y⌋%(Q : ℤ)=((gridIndex Q hQ (y : Circle)).val : ℤ) := by
    rw [←Int.sub_mul_emod_self_right ⌊(Q : ℝ)*y⌋ ⌊y⌋ (Q : ℤ),←hb]
    exact Int.emod_eq_of_lt (by omega) (by exact_mod_cast (gridIndex Q hQ (y : Circle)).isLt)
  apply Fin.ext
  simp only [gridIntIndex]
  rw [hm,Int.toNat_natCast]

noncomputable def gridIntLabel (Q : ℕ) (hQ : 0<Q) (v : ℤ×ℤ) : Fin (Q*Q+1) :=
  (finProdFinEquiv (gridIntIndex Q hQ v.1,gridIntIndex Q hQ v.2)).castSucc
lemma gridLabel_complex_lift (Q : ℕ) (hQ : 0<Q) (w : ℂ) :
    gridLabel Q hQ (complexProjection w)=gridIntLabel Q hQ (⌊(Q : ℝ)*w.re⌋,⌊(Q : ℝ)*w.im⌋) := by
  simp only [gridLabel,complexProjection,gridIndex_coe_int,gridIntLabel]
lemma floor_close_int {x y : ℝ} {M : ℕ} (h : |x-y|≤M) :
    ⌊x⌋∈Finset.Icc (⌊y⌋-(M : ℤ)-1) (⌊y⌋+(M : ℤ)+1) := by
  have hx0 := Int.floor_le x
  have hx1 := Int.lt_floor_add_one x
  have hy0 := Int.floor_le y
  have hy1 := Int.lt_floor_add_one y
  have hl := (abs_le.mp h).1
  have hu := (abs_le.mp h).2
  apply Finset.mem_Icc.mpr
  constructor
  · have hh : ((⌊y⌋-(M : ℤ)-1 : ℤ) : ℝ)≤(⌊x⌋ : ℝ) := by push_cast; linarith
    exact_mod_cast hh
  · have hh : (⌊x⌋ : ℝ)≤((⌊y⌋+(M : ℤ)+1 : ℤ) : ℝ) := by push_cast; linarith
    exact_mod_cast hh
noncomputable def liftGridCover (Q : ℕ) (hQ : 0<Q) (c : ℂ) (M : ℕ) : Finset (Fin (Q*Q+1)) :=
  ((Finset.Icc (⌊(Q : ℝ)*c.re⌋-(M : ℤ)-1) (⌊(Q : ℝ)*c.re⌋+(M : ℤ)+1)).product
    (Finset.Icc (⌊(Q : ℝ)*c.im⌋-(M : ℤ)-1) (⌊(Q : ℝ)*c.im⌋+(M : ℤ)+1))).image (gridIntLabel Q hQ)
lemma liftGridCover_card (Q : ℕ) (hQ : 0<Q) (c : ℂ) (M : ℕ) :
    (liftGridCover Q hQ c M).card≤(2*M+3)^2 := by
  apply (Finset.card_image_le).trans
  simp only [Finset.card,Finset.product,Multiset.card_product]
  change (Finset.Icc (⌊(Q : ℝ)*c.re⌋-(M : ℤ)-1) (⌊(Q : ℝ)*c.re⌋+(M : ℤ)+1)).card *
    (Finset.Icc (⌊(Q : ℝ)*c.im⌋-(M : ℤ)-1) (⌊(Q : ℝ)*c.im⌋+(M : ℤ)+1)).card ≤ _
  rw [Int.card_Icc,Int.card_Icc]
  have h1 : (⌊(Q : ℝ)*c.re⌋+(M : ℤ)+1+1-(⌊(Q : ℝ)*c.re⌋-(M : ℤ)-1)).toNat=2*M+3 := by omega
  have h2 : (⌊(Q : ℝ)*c.im⌋+(M : ℤ)+1+1-(⌊(Q : ℝ)*c.im⌋-(M : ℤ)-1)).toNat=2*M+3 := by omega
  rw [h1,h2,pow_two]
lemma liftGridCover_mem (Q : ℕ) (hQ : 0<Q) (c w : ℂ) (M : ℕ)
    (hw : ‖w-c‖≤(M : ℝ)/(Q : ℝ)) : gridLabel Q hQ (complexProjection w)∈liftGridCover Q hQ c M := by
  have hQpos : (0 : ℝ)<Q := Nat.cast_pos.mpr hQ
  have hr : |(Q : ℝ)*w.re-(Q : ℝ)*c.re|≤M := by
    rw [←mul_sub,abs_mul,abs_of_pos hQpos]
    have h := (Complex.abs_re_le_norm (w-c)).trans hw
    exact (mul_le_mul_of_nonneg_left h hQpos.le).trans_eq (mul_div_cancel₀ _ hQpos.ne')
  have hi : |(Q : ℝ)*w.im-(Q : ℝ)*c.im|≤M := by
    rw [←mul_sub,abs_mul,abs_of_pos hQpos]
    have h := (Complex.abs_im_le_norm (w-c)).trans hw
    exact (mul_le_mul_of_nonneg_left h hQpos.le).trans_eq (mul_div_cancel₀ _ hQpos.ne')
  rw [gridLabel_complex_lift]
  apply Finset.mem_image.mpr
  refine ⟨(⌊(Q : ℝ)*w.re⌋,⌊(Q : ℝ)*w.im⌋),?_,rfl⟩
  exact Finset.mem_product.mpr ⟨floor_close_int hr,floor_close_int hi⟩

end StandardMapEntropy

end
section
namespace StandardMapEntropy
open MeasureTheory Set Filter
open scoped BigOperators ENNReal Topology

lemma PlaneAreaPreserving.thin_cover {A : ℂ →L[ℝ] ℂ} (hA : PlaneAreaPreserving A) :
    ∃ (a : ℂ) (J : Finset ℤ),‖a‖=1 ∧ (J.card : ℝ)≤7*‖A‖ ∧
      ∀ v y : ℂ,‖v‖≤2 → ‖y-A v‖≤1 →
      ∃ j∈J,‖y-((j : ℝ)/‖A‖) • A a‖≤4 := by
  obtain ⟨a,ha,hAa,_,hAb,hL⟩ := hA.singular_pair
  have hLp : 0<‖A‖ := lt_of_lt_of_le zero_lt_one hL
  let N := ⌈2*‖A‖⌉₊
  have hN : 2*‖A‖≤(N : ℝ) := Nat.le_ceil _
  have hNb : (N : ℝ)<2*‖A‖+1 := Nat.ceil_lt_add_one (by positivity)
  let J := Finset.Icc (-(N : ℤ)) (N : ℤ)
  have hc : (J.card : ℝ)≤7*‖A‖ := by
    have hj : J.card=2*N+1 := by dsimp [J]; rw [Int.card_Icc]; omega
    rw [hj]
    push_cast
    nlinarith
  refine ⟨a,J,ha,hc,?_⟩
  intro v y hv hy
  have hd : |dot a v|≤2 := by simpa only [ha,one_mul] using (abs_dot_le_norm_mul a v).trans (by simpa [ha] using hv)
  have hw : |wedge a v|≤2 := by simpa only [ha,one_mul] using (abs_wedge_le_norm_mul a v).trans (by simpa [ha] using hv)
  let t := dot a v*‖A‖
  have ht : |t|≤(N : ℝ) := by
    dsimp [t]
    rw [abs_mul,abs_of_pos hLp]
    exact (mul_le_mul_of_nonneg_right hd hLp.le).trans hN
  have hj : ⌊t⌋∈J := by
    apply Finset.mem_Icc.mpr
    constructor
    · apply Int.le_floor.mpr
      simpa only [Int.cast_neg,Int.cast_natCast] using (abs_le.mp ht).1
    · apply Int.floor_le_iff.mpr
      simpa only [Int.cast_natCast] using lt_of_le_of_lt (abs_le.mp ht).2 (lt_add_one _)
  have hmajor : ‖(dot a v-(⌊t⌋ : ℝ)/‖A‖) • A a‖≤1 := by
    rw [norm_smul,Real.norm_eq_abs,hAa]
    have he : |dot a v-(⌊t⌋ : ℝ)/‖A‖| *‖A‖=|t-(⌊t⌋ : ℝ)| := by
      rw [←abs_of_pos hLp,←abs_mul]
      congr 1
      dsimp only [t]
      rw [abs_of_pos hLp]
      field_simp
    rw [he]
    exact abs_le.mpr ⟨by linarith [Int.floor_le t],by linarith [Int.lt_floor_add_one t]⟩
  have hminor : ‖(wedge a v) • A (quarterTurn a)‖≤2 := by
    rw [norm_smul,Real.norm_eq_abs,hAb]
    exact (mul_le_mul hw ((inv_le_one₀ hLp).mpr hL) (inv_nonneg.mpr hLp.le) (by norm_num)).trans_eq (mul_one _)
  have he : A v-((⌊t⌋ : ℝ)/‖A‖) • A a=
      (dot a v-(⌊t⌋ : ℝ)/‖A‖) • A a+(wedge a v) • A (quarterTurn a) := by
    conv_lhs => rw [unit_expansion a v ha]
    rw [map_add,map_smul,map_smul,sub_smul]
    abel
  refine ⟨⌊t⌋,hj,?_⟩
  have hn : ‖y-(((⌊t⌋ : ℝ)/‖A‖) • A a)‖≤‖y-A v‖+‖A v-(((⌊t⌋ : ℝ)/‖A‖) • A a)‖ := by
    simpa only [sub_add_sub_cancel] using norm_add_le (y-A v) (A v-(((⌊t⌋ : ℝ)/‖A‖) • A a))
  rw [he] at hn
  have hab := norm_add_le ((dot a v-(⌊t⌋ : ℝ)/‖A‖) • A a) ((wedge a v) • A (quarterTurn a))
  linarith

lemma PlaneAreaPreserving.grid_cover {A : ℂ →L[ℝ] ℂ} (hA : PlaneAreaPreserving A)
    (Q : ℕ) (hQ : 0<Q) (c : ℂ) :
    ∃ S : Finset (Fin (Q*Q+1)),(S.card : ℝ)≤1000*‖A‖ ∧
      ∀ v w : ℂ,‖v‖≤2/(Q : ℝ) → ‖w-c-A v‖≤1/(Q : ℝ) →
        gridLabel Q hQ (complexProjection w)∈S := by
  obtain ⟨a,J,ha,hJ,hcover⟩ := hA.thin_cover
  have hQp : (0 : ℝ)<Q := Nat.cast_pos.mpr hQ
  have hAp : 0<‖A‖ := lt_of_lt_of_le zero_lt_one hA.singular_pair.choose_spec.2.2.2.2
  let center : ℤ → ℂ := fun j => c+((j : ℝ)/((Q : ℝ)*‖A‖)) • A a
  let S : Finset (Fin (Q*Q+1)) := J.biUnion (fun j => liftGridCover Q hQ (center j) 4)
  have hcard : (S.card : ℝ)≤1000*‖A‖ := by
    have hn : S.card≤J.card*121 := calc
      _ ≤ ∑ j∈J,(liftGridCover Q hQ (center j) 4).card := Finset.card_biUnion_le
      _ ≤ ∑ _j∈J,121 := Finset.sum_le_sum (fun j _ => by simpa using liftGridCover_card Q hQ (center j) 4)
      _ = _ := by simp
    have hr : (S.card : ℝ)≤(J.card : ℝ)*121 := by exact_mod_cast hn
    nlinarith [norm_nonneg A]
  refine ⟨S,hcard,?_⟩
  intro v w hv hw
  have hv' : ‖(Q : ℝ) • v‖≤2 := by
    rw [norm_smul,Real.norm_eq_abs,abs_of_pos hQp]
    exact (mul_le_mul_of_nonneg_left hv hQp.le).trans_eq (mul_div_cancel₀ _ hQp.ne')
  have hw' : ‖(Q : ℝ) • (w-c)-A ((Q : ℝ) • v)‖≤1 := by
    rw [map_smul,←smul_sub,norm_smul,Real.norm_eq_abs,abs_of_pos hQp]
    exact (mul_le_mul_of_nonneg_left hw hQp.le).trans_eq (mul_div_cancel₀ _ hQp.ne')
  obtain ⟨j,hj,hij⟩ := hcover ((Q : ℝ) • v) ((Q : ℝ) • (w-c)) hv' hw'
  have he : (Q : ℝ) • (w-center j)=(Q : ℝ) • (w-c)-((j : ℝ)/‖A‖) • A a := by
    simp only [center]
    rw [show w-(c+((j : ℝ)/((Q : ℝ)*‖A‖)) • A a)=
      (w-c)-((j : ℝ)/((Q : ℝ)*‖A‖)) • A a by abel,
      smul_sub,smul_smul]
    congr 2
    field_simp
  rw [←he,norm_smul,Real.norm_eq_abs,abs_of_pos hQp] at hij
  have hclose : ‖w-center j‖≤(4 : ℝ)/(Q : ℝ) := by
    apply (le_div_iff₀ hQp).mpr
    simpa only [mul_comm] using hij
  exact Finset.mem_biUnion.mpr ⟨j,hj,liftGridCover_mem Q hQ (center j) w 4 hclose⟩

end StandardMapEntropy

end
section
namespace StandardMapEntropy
open MeasureTheory Set Filter
open scoped Topology ENNReal

lemma norm_sub_le_of_derivative_bound {E F : Type*}
    [NormedAddCommGroup E] [NormedSpace ℝ E] [NormedAddCommGroup F] [NormedSpace ℝ F]
    (f : E → F) (D : E → E →L[ℝ] F) (hD : ∀ x,HasFDerivAt f (D x) x)
    {B : ℝ} (hB : ∀ x,‖D x‖≤B) (x y : E) : ‖f x-f y‖≤B*‖x-y‖ := by
  exact (convex_univ : Convex ℝ (Set.univ : Set E)).norm_image_sub_le_of_norm_hasFDerivWithin_le
    (fun z _ => (hD z).hasFDerivWithinAt) (fun z _ => hB z) (Set.mem_univ y) (Set.mem_univ x)

lemma standardLift_iterate_control (k : ℝ) (hk : 0≤k) (n : ℕ) :
    ∃ B C : ℝ,0<B ∧ 0≤C ∧
      (∀ z : ℂ,‖standardDerivativeProduct k (complexProjection z) n‖≤B) ∧
      (∀ z w : ℂ,‖standardDerivativeProduct k (complexProjection z) n-
         standardDerivativeProduct k (complexProjection w) n‖≤C*‖z-w‖) := by
  induction n with
  | zero =>
    refine ⟨1,0,zero_lt_one,le_rfl,?_,?_⟩
    · intro z
      simp only [standardDerivativeProduct_zero,ContinuousLinearMap.norm_id,le_refl]
    · intro z w
      simp only [standardDerivativeProduct_zero,sub_self,norm_zero,zero_mul,le_refl]
  | succ n ih =>
    obtain ⟨B,C,hB,hC,hbound,hLip⟩ := ih
    let D := 9*growthBase k
    have hD : 0<D := by
      have hg := growthBase_ge_four k hk
      dsimp [D]
      linarith
    have hf : ∀ z w : ℂ,‖(standardLift k)^[n] z-(standardLift k)^[n] w‖≤B*‖z-w‖ :=
      norm_sub_le_of_derivative_bound _ _ (hasFDerivAt_standardLift_iterate k n) hbound
    refine ⟨D*B,derivativeVariationBound k*B^2+D*C,mul_pos hD hB,
      add_nonneg (mul_nonneg (derivativeVariationBound_nonneg k) (sq_nonneg B)) (mul_nonneg hD.le hC),?_,?_⟩
    · intro z
      exact (ContinuousLinearMap.opNorm_comp_le _ _).trans
        (mul_le_mul (standardDerivative_norm_bound k hk _) (hbound z) (norm_nonneg _) hD.le)
    · intro z w
      let Az := standardDerivative k ((standardMap k)^[n] (complexProjection z))
      let Aw := standardDerivative k ((standardMap k)^[n] (complexProjection w))
      let Pz := standardDerivativeProduct k (complexProjection z) n
      let Pw := standardDerivativeProduct k (complexProjection w) n
      have he : Az.comp Pz-Aw.comp Pw=(Az-Aw).comp Pz+Aw.comp (Pz-Pw) := by
        ext v
        simp only [sub_apply,add_apply,ContinuousLinearMap.comp_apply,map_sub]
        abel
      have hdiff : ‖Az-Aw‖≤derivativeVariationBound k*(B*‖z-w‖) := by
        have hh := standardDerivative_lift_sub_bound k ((standardLift k)^[n] z) ((standardLift k)^[n] w)
        rw [complexProjection_iterate,complexProjection_iterate] at hh
        exact hh.trans (mul_le_mul_of_nonneg_left (hf z w) (derivativeVariationBound_nonneg k))
      change ‖Az.comp Pz-Aw.comp Pw‖≤_
      rw [he]
      calc
        _ ≤ ‖(Az-Aw).comp Pz‖+‖Aw.comp (Pz-Pw)‖ := norm_add_le _ _
        _ ≤ ‖Az-Aw‖*‖Pz‖+‖Aw‖*‖Pz-Pw‖ :=
          add_le_add (ContinuousLinearMap.opNorm_comp_le _ _) (ContinuousLinearMap.opNorm_comp_le _ _)
        _ ≤ (derivativeVariationBound k*(B*‖z-w‖))*B+D*(C*‖z-w‖) := by
          apply add_le_add
          · exact mul_le_mul hdiff (hbound z) (norm_nonneg _) (mul_nonneg (derivativeVariationBound_nonneg k) (mul_nonneg hB.le (norm_nonneg _)))
          · exact mul_le_mul (standardDerivative_norm_bound k hk _) (hLip z w) (norm_nonneg _) hD.le
        _ = _ := by ring

lemma log_norm_sub_le_of_one_le {E : Type*} [SeminormedAddCommGroup E] {a b : E}
    (ha : 1≤‖a‖) (hb : 1≤‖b‖) : |Real.log ‖a‖-Real.log ‖b‖|≤‖a-b‖ := by
  have ha0 : 0<‖a‖ := lt_of_lt_of_le zero_lt_one ha
  have hb0 : 0<‖b‖ := lt_of_lt_of_le zero_lt_one hb
  have hab := Real.log_le_sub_one_of_pos (div_pos ha0 hb0)
  have hba := Real.log_le_sub_one_of_pos (div_pos hb0 ha0)
  rw [Real.log_div ha0.ne' hb0.ne'] at hab
  rw [Real.log_div hb0.ne' ha0.ne'] at hba
  have hd := norm_sub_norm_le a b
  have hd' := norm_sub_norm_le b a
  rw [norm_sub_rev b a] at hd'
  apply abs_le.mpr
  constructor
  · have hh : ‖b‖/‖a‖-1≤‖a-b‖ := by
      apply (sub_le_iff_le_add).mpr
      apply (div_le_iff₀ ha0).mpr
      nlinarith [norm_nonneg (a-b)]
    linarith
  · have hh : ‖a‖/‖b‖-1≤‖a-b‖ := by
      apply (sub_le_iff_le_add).mpr
      apply (div_le_iff₀ hb0).mpr
      nlinarith [norm_nonneg (a-b)]
    exact hab.trans hh

end StandardMapEntropy

end
section
namespace StandardMapEntropy.Entropy
open Set Finset
open scoped BigOperators

noncomputable def shannon {α : Type*} [Fintype α] (p : α → ℝ) : ℝ :=
  ∑ a, Real.negMulLog (p a)

lemma negMulLog_le_cross {p q : ℝ} (hp : 0≤p) (hq : 0≤q) (hs : p≠0 → q≠0) :
    Real.negMulLog p≤ -p*Real.log q+q-p := by
  by_cases he : p=0
  · simp only [he,Real.negMulLog_zero,neg_zero,zero_mul,sub_zero,zero_add]
    exact hq
  have hp' : 0<p := lt_of_le_of_ne hp (Ne.symm he)
  have hq' : 0<q := lt_of_le_of_ne hq (Ne.symm (hs he))
  have hh := mul_le_mul_of_nonneg_left (Real.log_le_sub_one_of_pos (div_pos hq' hp')) hp
  rw [Real.log_div hq'.ne' hp'.ne'] at hh
  have hc : p*(q/p-1)=q-p := by field_simp
  rw [hc] at hh
  dsimp [Real.negMulLog]
  nlinarith

lemma shannon_le_cross {α : Type*} [Fintype α] (p q : α → ℝ)
    (hp : ∀ a, 0≤p a) (hq : ∀ a, 0≤q a) (hs : ∀ a, p a≠0 → q a≠0)
    (hm : ∑ a,q a≤∑ a,p a) :
    shannon p≤ -∑ a,p a*Real.log (q a) := by
  have hh := Finset.sum_le_sum (s:=Finset.univ) (fun a _ => negMulLog_le_cross (hp a) (hq a) (hs a))
  simp only [Finset.sum_sub_distrib,Finset.sum_add_distrib,neg_mul,Finset.sum_neg_distrib] at hh
  dsimp [shannon]
  linarith

lemma shannon_nonneg {α : Type*} [Fintype α] (p : α → ℝ)
    (hp : ∀ a, 0≤p a) (hm : ∑ a,p a≤1) : 0 ≤ shannon p := by
  apply Finset.sum_nonneg
  intro a _
  exact Real.negMulLog_nonneg (hp a) ((Finset.single_le_sum (fun b _ => hp b) (Finset.mem_univ a)).trans hm)

lemma shannon_scale {α : Type*} [Fintype α] (p : α → ℝ) (c : ℝ) :
    shannon (fun a => c*p a)=c*shannon p+(∑ a,p a)*Real.negMulLog c := by
  simp only [shannon,Real.negMulLog_mul,Finset.sum_add_distrib,←Finset.mul_sum,←Finset.sum_mul]
  ring

lemma shannon_bound {α : Type*} [Fintype α] [Nonempty α] (p : α → ℝ)
    (hp : ∀ a, 0≤p a) (hm : ∑ a,p a=1) : shannon p≤Real.log (Fintype.card α) := by
  have hc : 0<(Fintype.card α : ℝ) := by exact_mod_cast Fintype.card_pos
  have hh := shannon_le_cross p (fun _ => (Fintype.card α : ℝ)⁻¹) hp
    (fun _ => (inv_pos.mpr hc).le) (fun _ _ => inv_ne_zero hc.ne') (by simp [hm,hc.ne'])
  rw [←Finset.sum_mul,hm,one_mul,Real.log_inv,neg_neg] at hh
  exact hh

lemma matrix_row_nonneg {α β : Type*} [Fintype α] [Fintype β]
    (p : α → β → ℝ) (hp : ∀ a b, 0≤p a b) (a : α) : 0≤∑ b,p a b :=
  Finset.sum_nonneg (fun b _ => hp a b)
lemma matrix_col_nonneg {α β : Type*} [Fintype α] [Fintype β]
    (p : α → β → ℝ) (hp : ∀ a b, 0≤p a b) (b : β) : 0≤∑ a,p a b :=
  Finset.sum_nonneg (fun a _ => hp a b)
lemma matrix_le_row {α β : Type*} [Fintype α] [Fintype β]
    (p : α → β → ℝ) (hp : ∀ a b, 0≤p a b) (a : α) (b : β) : p a b≤∑ j,p a j :=
  Finset.single_le_sum (fun j _ => hp a j) (Finset.mem_univ b)
lemma matrix_le_col {α β : Type*} [Fintype α] [Fintype β]
    (p : α → β → ℝ) (hp : ∀ a b, 0≤p a b) (a : α) (b : β) : p a b≤∑ i,p i b :=
  Finset.single_le_sum (fun i _ => hp i b) (Finset.mem_univ a)

lemma matrix_subadd {α β : Type*} [Fintype α] [Fintype β]
    (p : α → β → ℝ) (hp : ∀ a b, 0≤p a b) :
    shannon (fun ab : α×β => p ab.1 ab.2)≤
      shannon (fun a => ∑ b,p a b)+shannon (fun b => ∑ a,p a b)-
        Real.negMulLog (∑ a,∑ b,p a b) := by
  let A : α → ℝ := fun a => ∑ b,p a b
  let B : β → ℝ := fun b => ∑ a,p a b
  let T : ℝ := ∑ a,∑ b,p a b
  have hA := matrix_row_nonneg p hp
  have hB := matrix_col_nonneg p hp
  have hT : 0≤T := Finset.sum_nonneg (fun a _ => hA a)
  have hpT (a : α) (b : β) : p a b≤T := (matrix_le_row p hp a b).trans
    (Finset.single_le_sum (fun i _ => hA i) (Finset.mem_univ a))
  by_cases he : T=0
  · have hz (a : α) (b : β) : p a b=0 := le_antisymm (by simpa only [he] using hpT a b) (hp a b)
    simp only [shannon,hz,Finset.sum_const_zero,Real.negMulLog_zero,add_zero,sub_zero,le_refl]
  have hT' : 0<T := lt_of_le_of_ne hT (Ne.symm he)
  let q : α×β → ℝ := fun ab => A ab.1*B ab.2/T
  have hq (ab : α×β) : 0≤q ab := div_nonneg (mul_nonneg (hA ab.1) (hB ab.2)) hT
  have hs (ab : α×β) (hh : p ab.1 ab.2≠0) : q ab≠0 := by
    have hpos : 0<p ab.1 ab.2 := lt_of_le_of_ne (hp _ _) (Ne.symm hh)
    exact div_ne_zero (mul_ne_zero (ne_of_gt (hpos.trans_le (matrix_le_row p hp _ _)))
      (ne_of_gt (hpos.trans_le (matrix_le_col p hp _ _)))) he
  have hmass : ∑ ab : α×β,q ab=∑ ab : α×β,p ab.1 ab.2 := by
    simp only [q,Fintype.sum_prod_type,←Finset.sum_div,←Finset.mul_sum,←Finset.sum_mul]
    have hsumA : ∑ a,A a=T := rfl
    have hsumB : ∑ b,B b=T := by dsimp [B,T]; exact Finset.sum_comm
    rw [hsumA,hsumB,mul_div_cancel_right₀ _ he]
  have hh := shannon_le_cross (fun ab : α×β => p ab.1 ab.2) q (fun ab => hp ab.1 ab.2) hq hs hmass.le
  have hlog (a : α) (b : β) : p a b*Real.log (q (a,b))=
      p a b*Real.log (A a)+p a b*Real.log (B b)-p a b*Real.log T := by
    by_cases hz : p a b=0
    · simp only [hz,zero_mul,add_zero,sub_zero]
    have hpos : 0<p a b := lt_of_le_of_ne (hp a b) (Ne.symm hz)
    have ha : A a≠0 := ne_of_gt (hpos.trans_le (matrix_le_row p hp a b))
    have hb : B b≠0 := ne_of_gt (hpos.trans_le (matrix_le_col p hp a b))
    rw [show q (a,b)=A a*B b/T from rfl,Real.log_div (mul_ne_zero ha hb) he,Real.log_mul ha hb]
    ring
  have hsum1 : ∑ a,∑ b,p a b*Real.log (A a)=∑ a,A a*Real.log (A a) := by
    apply Finset.sum_congr rfl
    intro a _
    rw [←Finset.sum_mul]
  have hsum2 : ∑ a,∑ b,p a b*Real.log (B b)=∑ b,B b*Real.log (B b) := by
    rw [Finset.sum_comm]
    apply Finset.sum_congr rfl
    intro b _
    rw [←Finset.sum_mul]
  have hsum3 : ∑ a,∑ b,p a b*Real.log T=T*Real.log T := by simp only [←Finset.sum_mul]; rfl
  simp only [Fintype.sum_prod_type,hlog,Finset.sum_sub_distrib,Finset.sum_add_distrib] at hh
  rw [hsum1,hsum2,hsum3] at hh
  dsimp only [shannon,Real.negMulLog] at hh ⊢
  simp only [neg_mul,Finset.sum_neg_distrib] at hh ⊢
  change _≤ -(∑ a,A a*Real.log (A a)) + -(∑ b,B b*Real.log (B b)) - (-(T*Real.log T))
  linarith

lemma shannon_total_bound {α : Type*} [Fintype α] (p : α → ℝ)
    (hp : ∀ a, 0≤p a) : shannon p≤Real.negMulLog (∑ a,p a)+(∑ a,p a)*Real.log (Fintype.card α) := by
  let T : ℝ := ∑ a,p a
  have hT : 0≤T := Finset.sum_nonneg (fun a _ => hp a)
  by_cases he : T=0
  · have hz (a : α) : p a=0 := le_antisymm
      ((Finset.single_le_sum (fun b _ => hp b) (Finset.mem_univ a) : p a≤T).trans_eq he) (hp a)
    simp only [shannon,hz,Finset.sum_const_zero,Real.negMulLog_zero,zero_mul,add_zero,le_refl]
  have hT' : 0<T := lt_of_le_of_ne hT (Ne.symm he)
  have : Nonempty α := by
    by_contra h
    have : IsEmpty α := not_nonempty_iff.mp h
    exact he (by dsimp [T]; simp)
  let q : α → ℝ := fun a => p a/T
  have hq (a : α) : 0≤q a := div_nonneg (hp a) hT
  have hmass : ∑ a,q a=1 := by dsimp [q]; rw [←Finset.sum_div]; exact div_self he
  have hb := mul_le_mul_of_nonneg_left (shannon_bound q hq hmass) hT
  have hs := shannon_scale q T
  have heq : (fun a => T*q a)=p := by funext a; dsimp [q]; field_simp
  rw [heq,hmass,one_mul] at hs
  change shannon p≤Real.negMulLog T+T*Real.log (Fintype.card α)
  linarith

lemma matrix_super_row {α β : Type*} [Fintype α] [Fintype β]
    (p : α → β → ℝ) (hp : ∀ a b, 0≤p a b) :
    shannon (fun a => ∑ b,p a b)≤ shannon (fun ab : α×β => p ab.1 ab.2) := by
  have hh (a : α) (b : β) : -p a b*Real.log (∑ j,p a j)≤Real.negMulLog (p a b) := by
    by_cases he : p a b=0
    · simp [he]
    have hpos : 0<p a b := lt_of_le_of_ne (hp a b) (Ne.symm he)
    have hlog := Real.log_le_log hpos (matrix_le_row p hp a b)
    exact mul_le_mul_of_nonpos_left hlog (neg_nonpos.mpr (hp a b))
  have hs := Finset.sum_le_sum (s:=Finset.univ) (fun a _ => Finset.sum_le_sum (s:=Finset.univ) (fun b _ => hh a b))
  simp only [neg_mul,←Finset.sum_mul,Finset.sum_neg_distrib] at hs
  simpa only [shannon,Fintype.sum_prod_type,Real.negMulLog,neg_mul,Finset.sum_neg_distrib] using hs

end StandardMapEntropy.Entropy

end
end

end OAI