import OAI.Analysis.DiamondDistortion.GraphBounds

namespace OAI

universe u v

noncomputable section
open scoped BigOperators Classical Topology
open Set

namespace DiamondDistortion

open scoped ENNReal

open scoped ENNReal Classical
open Filter Topology
namespace LpDual
variable {ι : Type*} (E : ι → Type*) [∀ i,NormedAddCommGroup (E i)] [∀ i,NormedSpace ℝ (E i)]
  (p : ℝ≥0∞) [Fact (1 ≤ p)]

def finite : (Π₀ i,E i) →ₗ[ℝ] lp E p where
  toFun v := ⟨(fun i => v i),(memℓp_zero (by
    classical
    have he : {i | v i ≠ 0}=(v.support : Set ι) := by ext i; simp
    rw [he]
    exact v.support.finite_toSet)).of_exponent_ge bot_le⟩
  map_add' v w := by ext i; rfl
  map_smul' c v := by ext i; rfl
@[simp] lemma finite_apply {ι : Type*} (E : ι → Type*) [∀ i,NormedAddCommGroup (E i)] [∀ i,NormedSpace ℝ (E i)] (p : ℝ≥0∞) [Fact (1 ≤ p)] (v : Π₀ i,E i) (i : ι) : finite E p v i=v i := rfl
lemma finite_injective {ι : Type*} (E : ι → Type*) [∀ i,NormedAddCommGroup (E i)] [∀ i,NormedSpace ℝ (E i)] (p : ℝ≥0∞) [Fact (1 ≤ p)] : Function.Injective (finite E p) := by
  intro v w he
  ext i
  exact congrArg (fun x : lp E p => x i) he
lemma finite_norm_add {ι : Type*} (E : ι → Type*) [∀ i,NormedAddCommGroup (E i)] [∀ i,NormedSpace ℝ (E i)] (p : ℝ≥0∞) [Fact (1 ≤ p)] {r : ℝ} (hr : r=p.toReal) (hp : 0 < p.toReal) (v w : Π₀ i,E i)
    (hd : Disjoint v.support w.support) :
    ‖finite E p (v+w)‖^r=‖finite E p v‖^r+‖finite E p w‖^r := by
  classical
  subst r
  rw [lp.norm_rpow_eq_tsum hp,lp.norm_rpow_eq_tsum hp,lp.norm_rpow_eq_tsum hp,
    ← ((finite E p v).property.summable hp).tsum_add ((finite E p w).property.summable hp)]
  apply tsum_congr
  intro i
  simp only [finite_apply,DFinsupp.add_apply]
  have hz : v i=0 ∨ w i=0 := by
    by_cases h : v i=0
    · exact Or.inl h
    · right
      by_contra hh
      exact (Finset.disjoint_left.mp hd) (DFinsupp.mem_support_iff.mpr h) (DFinsupp.mem_support_iff.mpr hh)
  rcases hz with h|h <;> simp [h,Real.zero_rpow hp.ne']

lemma small_tail_upper (hp : 1 < p.toReal) (x : StrongDual ℝ (lp E p)) {ε : ℝ} (hε : 0 < ε) :
    ∃ C : Finset ι, ∀ v : Π₀ i,E i, (∀ i ∈ v.support,i ∉ C) →
      x (finite E p v) ≤ ε*‖finite E p v‖ := by
  classical
  have hp0 : 0 < p.toReal := lt_trans zero_lt_one hp
  by_contra hn
  push Not at hn
  have hchoose (C : Finset ι) : ∃ q : Π₀ i,E i,
      (∀ i ∈ q.support,i ∉ C) ∧ ‖finite E p q‖=1 ∧ ε < x (finite E p q) := by
    obtain ⟨v,hout,hval⟩ := hn C
    have hvn0 : ‖finite E p v‖ ≠ 0 := by
      intro he
      have hv0 : v=0 := finite_injective E p (by simpa using norm_eq_zero.mp he)
      simp only [hv0,map_zero,norm_zero,mul_zero,lt_self_iff_false] at hval
    have hvn : 0 < ‖finite E p v‖ := lt_of_le_of_ne (norm_nonneg _) hvn0.symm
    let q := ‖finite E p v‖⁻¹ • v
    refine ⟨q, ?_, ?_, ?_⟩
    · intro i hi
      exact hout i (DFinsupp.support_smul _ v hi)
    · simp only [q,map_smul,norm_smul,Real.norm_eq_abs,abs_of_pos (inv_pos.mpr hvn)]
      exact inv_mul_cancel₀ hvn0
    · simp only [q,map_smul,smul_eq_mul]
      rw [inv_mul_eq_div]
      exact (lt_div_iff₀ hvn).mpr hval
  have hblocks : ∀ n : ℕ,∃ v : Π₀ i,E i,
      ‖finite E p v‖^p.toReal ≤ (n:ℝ) ∧ (n:ℝ)*ε ≤ x (finite E p v) := by
    intro n
    induction n with
    | zero => exact ⟨0,by simp [Real.zero_rpow hp0.ne'],by simp⟩
    | succ n ih =>
      obtain ⟨v,hvn,hvx⟩ := ih
      obtain ⟨q,hqout,hqn,hqx⟩ := hchoose v.support
      have hd : Disjoint v.support q.support := by
        exact Finset.disjoint_left.mpr (fun i hiv hiq => hqout i hiq hiv)
      refine ⟨v+q, ?_, ?_⟩
      · rw [finite_norm_add E p rfl hp0 v q hd,hqn,Real.one_rpow]
        push_cast
        linarith
      · simp only [map_add,Nat.cast_add,Nat.cast_one]
        linarith
  have ht : Tendsto (fun n : ℕ => (n:ℝ)^(p.toReal-1)) atTop atTop :=
    (tendsto_rpow_atTop (sub_pos.mpr hp)).comp tendsto_natCast_atTop_atTop
  obtain ⟨n,hn,hn0⟩ := ((ht.eventually_gt_atTop (‖x‖^p.toReal/ε^p.toReal)).and
    (eventually_gt_atTop (0:ℕ))).exists
  have hnR : (0:ℝ)<n := by exact_mod_cast hn0
  have hnε : ‖x‖^p.toReal < (n:ℝ)^(p.toReal-1)*ε^p.toReal :=
    (div_lt_iff₀ (Real.rpow_pos_of_pos hε _)).mp hn
  obtain ⟨v,hvn,hvx⟩ := hblocks n
  have hxb : x (finite E p v) ≤ ‖x‖*‖finite E p v‖ :=
    (Real.le_norm_self _).trans (x.le_opNorm _)
  have hprod := hvx.trans hxb
  have hrpow := Real.rpow_le_rpow (mul_nonneg hnR.le hε.le) hprod hp0.le
  rw [Real.mul_rpow hnR.le hε.le,Real.mul_rpow (norm_nonneg _) (norm_nonneg _)] at hrpow
  have hmul := mul_le_mul_of_nonneg_left hvn (Real.rpow_nonneg (norm_nonneg x) p.toReal)
  have he : (n:ℝ)^p.toReal=(n:ℝ)*(n:ℝ)^(p.toReal-1) := by
    rw [Real.rpow_sub hnR]
    simp only [Real.rpow_one]
    field_simp
  rw [he] at hrpow
  have hh : (n:ℝ)*((n:ℝ)^(p.toReal-1)*ε^p.toReal) ≤ (n:ℝ)*‖x‖^p.toReal := by
    nlinarith
  exact (not_le.mpr hnε) ((mul_le_mul_iff_right₀ hnR).mp hh)

lemma small_tail (hp : 1 < p.toReal) (x : StrongDual ℝ (lp E p)) {ε : ℝ} (hε : 0 < ε) :
    ∃ C : Finset ι, ∀ v : Π₀ i,E i, (∀ i ∈ v.support,i ∉ C) →
      |x (finite E p v)| ≤ ε*‖finite E p v‖ := by
  obtain ⟨C,hC⟩ := small_tail_upper E p hp x hε
  refine ⟨C,?_⟩
  intro v hv
  apply abs_le.mpr
  refine ⟨?_,hC v hv⟩
  have h := hC (-v) (by simpa only [DFinsupp.support_neg] using hv)
  simp only [map_neg,norm_neg] at h
  linarith
@[simp] lemma finite_single {ι : Type*} (E : ι → Type*) [∀ i,NormedAddCommGroup (E i)] [∀ i,NormedSpace ℝ (E i)] (p : ℝ≥0∞) [Fact (1 ≤ p)] (i : ι) (v : E i) :
    finite E p (DFinsupp.single i v)=lp.single p i v := by
  ext j
  by_cases he : i=j
  · subst j
    simp [lp.single_apply]
  · simp [lp.single_apply,DFinsupp.single_apply,he]

lemma finite_dense (hp : p ≠ ⊤) : DenseRange (finite E p) := by
  intro v
  apply isClosed_closure.mem_of_tendsto (lp.hasSum_single hp v)
  apply Filter.Eventually.of_forall
  intro S
  apply subset_closure
  refine ⟨∑ i ∈ S,DFinsupp.single i (v i),?_⟩
  simp only [map_sum,finite_single]

def dualInclude (i : ι) : StrongDual ℝ (E i) →L[ℝ] StrongDual ℝ (lp E p) :=
  (lp.evalCLM ℝ E p i).precomp ℝ
lemma dualInclude_apply (i : ι) (x : StrongDual ℝ (E i)) (v : lp E p) :
    dualInclude E p i x v=x (v i) := rfl

def dualHead (C : Finset ι) (x : StrongDual ℝ (lp E p)) : StrongDual ℝ (lp E p) :=
  ∑ i ∈ C,dualInclude E p i (x.comp (lp.singleContinuousLinearMap ℝ E p i))
lemma dualHead_apply (C : Finset ι) (x : StrongDual ℝ (lp E p)) (v : lp E p) :
    dualHead E p C x v=∑ i ∈ C,x (lp.single p i (v i)) := by
  simp only [dualHead,sum_apply,dualInclude_apply,
    ContinuousLinearMap.comp_apply]
  rfl

lemma finite_filter (C : Finset ι) (v : Π₀ i,E i) :
    finite E p (v.filter (fun i => i ∈ C))=∑ i ∈ C,lp.single p i (v i) := by
  ext i
  rw [finite_apply,DFinsupp.filter_apply]
  simp only [lp.coeFn_sum,Finset.sum_apply,lp.single_apply]
  by_cases hi : i ∈ C
  · rw [ite_eq_left hi]
    symm
    calc
      _ = Pi.single i (v i) i := Finset.sum_eq_single i
        (fun j _ hji => Pi.single_eq_of_ne hji.symm _) (fun h => (h hi).elim)
      _ = _ := Pi.single_eq_same i (v i)
  · rw [ite_eq_right hi]
    apply Eq.symm
    apply Finset.sum_eq_zero
    intro j hj
    exact Pi.single_eq_of_ne (ne_of_mem_of_not_mem hj hi).symm _

lemma finite_filter_norm (Q : ι → Prop) [DecidablePred Q] (v : Π₀ i,E i) :
    ‖finite E p (v.filter Q)‖ ≤ ‖finite E p v‖ := by
  apply lp.norm_mono (ne_of_gt (zero_lt_one.trans_le (Fact.out : 1 ≤ p)))
  intro i
  simp only [finite_apply,DFinsupp.filter_apply]
  split_ifs <;> simp

lemma dual_approximation (hp : 1 < p.toReal) (x : StrongDual ℝ (lp E p)) {ε : ℝ} (hε : 0 < ε) :
    ∃ C : Finset ι, ‖x-dualHead E p C x‖ < ε := by
  have hptop : p ≠ ⊤ := by intro he; norm_num [he] at hp
  obtain ⟨C,hC⟩ := small_tail E p hp x (half_pos hε)
  refine ⟨C,?_⟩
  have hb : ‖x-dualHead E p C x‖ ≤ ε/2 := by
    apply ContinuousLinearMap.opNorm_le_bound _ (half_pos hε).le
    intro v
    refine (finite_dense E p hptop).induction_on (p := fun v =>
      ‖(x-dualHead E p C x) v‖ ≤ (ε/2)*‖v‖) v
      (isClosed_le ((x-dualHead E p C x).continuous.norm) (continuous_const.mul continuous_norm)) ?_
    intro w
    let wi := w.filter (fun i => i ∈ C)
    let wo := w.filter (fun i => i ∉ C)
    have hw : wi+wo=w := DFinsupp.filter_add_filter_not _ _
    have hh : dualHead E p C x (finite E p w)=x (finite E p wi) := by
      rw [dualHead_apply]
      dsimp [wi]
      rw [finite_filter,map_sum]
    have he : (x-dualHead E p C x) (finite E p w)=x (finite E p wo) := by
      change x (finite E p w)-dualHead E p C x (finite E p w)=_
      rw [hh,← hw,map_add,map_add]
      ring
    have ho : ∀ i ∈ wo.support,i ∉ C := by
      intro i hi hci
      have hz : wo i=0 := by simp [wo,DFinsupp.filter_apply,hci]
      exact (DFinsupp.mem_support_iff.mp hi) hz
    rw [he,Real.norm_eq_abs]
    exact (hC wo ho).trans (mul_le_mul_of_nonneg_left (finite_filter_norm E p _ w) (half_pos hε).le)
  exact hb.trans_lt (half_lt_self hε)

lemma dual_separable [Countable ι] [∀ i,TopologicalSpace.SeparableSpace (StrongDual ℝ (E i))]
    (hp : 1 < p.toReal) : TopologicalSpace.SeparableSpace (StrongDual ℝ (lp E p)) := by
  let S : Set (StrongDual ℝ (lp E p)) := ⋃ i,Set.range (dualInclude E p i)
  let V := Submodule.span ℝ S
  have hd : Dense (V : Set (StrongDual ℝ (lp E p))) := by
    intro x
    apply Metric.mem_closure_iff.mpr
    intro ε hε
    obtain ⟨C,hC⟩ := dual_approximation E p hp x hε
    refine ⟨dualHead E p C x,?_,?_⟩
    · apply Submodule.sum_mem
      intro i hi
      apply Submodule.subset_span
      apply Set.mem_iUnion.mpr
      exact ⟨i,_,rfl⟩
    · simpa only [dist_eq_norm] using hC
  apply hd.isSeparable_iff.mp
  apply TopologicalSpace.IsSeparable.span
  exact TopologicalSpace.IsSeparable.iUnion (fun i =>
    TopologicalSpace.isSeparable_range (dualInclude E p i).continuous)
end LpDual

end DiamondDistortion

end

end OAI