import OAI.NumberTheory.PrimeGaps.EqualityPatterns

namespace OAI

namespace LargePrimeGaps

open Filter

open Set Filter MeasureTheory

open scoped Topology ContDiff

open Asymptotics

open Asymptotics

open Asymptotics

open scoped Classical

open scoped ContDiff

open Topology

open scoped Convolution ContDiff Pointwise

theorem pattern_singular_sum {ι : Type*} [Fintype ι] (r : Setoid ι) (h : ℕ) (a : ℤ) :
    (∑ b∈patternClass (α:=Fin h) r,
      singularSeries (Finset.univ.image fun i => a+(b i:ℕ))) =
    ∑ n∈distinctBox (s:=Fintype.card (Quotient r)) (h:=h) (fun _ => a),
      singularSeries (Finset.univ.image (boxTuple (fun _ => a) n)) := by
  classical
  conv_lhs => rw [←Finset.sum_coe_sort]
  conv_rhs => rw [←Finset.sum_coe_sort]
  apply Fintype.sum_equiv (patternTupleEquiv r h a)
  intro b
  rw [patternTupleEquiv_image r h a b]

theorem ker_comp_injective {ι α β : Type*} (b : ι → α) (f : α → β) (hf : Function.Injective f) :
    Setoid.ker (f∘b)=Setoid.ker b := by
  apply Setoid.ext
  intro i j
  exact hf.eq_iff

theorem numericPattern_int_ker {ι : Type*} [Fintype ι] (r : Setoid ι) :
    Setoid.ker (fun i => (numericPattern r i:ℤ))=r := by
  have h := ker_comp_injective (numericPattern r) (fun n : ℕ => (n:ℤ)) (by intro m n hm; exact_mod_cast (show (m:ℤ)=(n:ℤ) from hm))
  exact h.trans (numericPattern_ker r)

theorem shiftFamily_eq_of_ker {ι : Type*} [Fintype ι] (b c : ι → ℤ)
    (h : Setoid.ker b=Setoid.ker c) : shiftFamily b=shiftFamily c := by
  classical
  ext S
  simp only [shiftFamily,mem_fiberSubsetFamily_image]
  have hc (i j : ι) : b i=b j ↔ c i=c j := by
    change (Setoid.ker b) i j ↔ (Setoid.ker c) i j
    rw [h]
  constructor <;> rintro ⟨hS,he⟩
  · exact ⟨hS,fun i hi j hj => (hc i j).mp (he i hi j hj)⟩
  · exact ⟨hS,fun i hi j hj => (hc i j).mpr (he i hi j hj)⟩

noncomputable def equalityPatternFamily {ι : Type*} [Fintype ι] (r : Setoid ι) :
    Finset (Finset ι) := shiftFamily (fun i => (numericPattern r i:ℤ))

theorem equalityPatternFamily_sign_sum {ι : Type*} [Fintype ι] (r : Setoid ι) :
    (∑ S∈equalityPatternFamily r,(-1:ℤ)^S.card)=-(Fintype.card (Quotient r):ℤ) := by
  classical
  rw [equalityPatternFamily,shiftFamily_sign_sum]
  have he : (Finset.univ.image fun i => (numericPattern r i:ℤ))=
      Finset.univ.image (fun j : Fin (Fintype.card (Quotient r)) => (j.val:ℤ)) := by
    ext v
    simp only [Finset.mem_image,Finset.mem_univ,true_and]
    constructor
    · rintro ⟨i,rfl⟩
      exact ⟨Fintype.equivFin (Quotient r) (Quotient.mk r i),rfl⟩
    · rintro ⟨j,rfl⟩
      obtain ⟨i,hi⟩ := Quotient.mk_surjective ((Fintype.equivFin (Quotient r)).symm j)
      refine ⟨i,?_⟩
      simp only [numericPattern,hi,Equiv.apply_symm_apply]
  rw [he,Finset.card_image_of_injective]
  · simp only [Finset.card_univ,Fintype.card_fin]
  · intro i j hij
    apply Fin.ext
    exact_mod_cast (show (i.val:ℤ)=(j.val:ℤ) from hij)

theorem translated_shiftFamily {ι : Type*} [Fintype ι] {h : ℕ}
    (r : Setoid ι) (a : ℕ) (b : ι → Fin h) (hb : b∈patternClass r) :
    shiftFamily (fun i => ((a+(b i).val:ℕ):ℤ))=equalityPatternFamily r := by
  apply shiftFamily_eq_of_ker
  rw [numericPattern_int_ker]
  have hi : Function.Injective (fun x : Fin h => ((a+x.val:ℕ):ℤ)) := by
    intro i j hij
    apply Fin.ext
    have hh : a+i.val=a+j.val := by exact_mod_cast (show ((a+i.val:ℕ):ℤ)=((a+j.val:ℕ):ℤ) from hij)
    exact Nat.add_left_cancel hh
  exact (ker_comp_injective b _ hi).trans ((mem_patternClass r b).mp hb)

theorem divisorSum_fin_zero (X M : ℕ) (F : (Fin 0 → ℝ) → ℝ) (b : Fin 0 → ℕ) :
    divisorSum X F M b=F 0 := by
  classical
  have h : Fintype.piFinset (fun i => (M+b i).divisors)={(0 : Fin 0 → ℕ)} := by
    ext d
    simp [funext_iff]
  rw [divisorSum,h,Finset.sum_singleton]
  simp only [divisorCoefficient,Fin.prod_univ_zero,one_mul]
  congr 1
  ext i
  exact Fin.elim0 i

theorem divisorSum_singleton_at_prime {X M b : ℕ} (hX : 2≤X) (hM : X<M+b)
    (hp : Nat.Prime (M+b)) (G : (Fin 1 → ℝ) → ℝ) {rho : ℝ}
    (hrho : rho<1) (hbudget : HasBudget G rho) :
    divisorSum X G M (fun _ => b)=G 0 := by
  have ht : (fun _ : Fin 1 => b)=Fin.snoc (0 : Fin 0 → ℕ) b := by ext i; fin_cases i; rfl
  rw [ht,divisorSum_prime_delete hX hM hp G hrho hbudget,divisorSum_fin_zero]
  congr 1

theorem theta_div_log_le_upper {X M b Y : ℕ} (hX : 2≤X) (hY : M+b≤Y) (hYP : 1≤Y) :
    theta (M+b)/Real.log X≤Real.log Y/Real.log X := by
  apply div_le_div_of_nonneg_right _ (log_pos_of_two_le hX).le
  by_cases hp : Nat.Prime (M+b)
  · rw [theta,ite_eq_left hp]
    exact Real.log_le_log (by exact_mod_cast hp.pos) (by exact_mod_cast hY)
  · rw [theta,ite_eq_right hp]
    exact Real.log_nonneg (by exact_mod_cast hYP)

theorem singleton_divisor_majorant {X M b Y : ℕ} (hX : 2≤X) (hM : X<M+b)
    (hY : M+b≤Y) (hYP : 1≤Y) (G : (Fin 1 → ℝ) → ℝ) {rho : ℝ}
    (hrho : rho<1) (hbudget : HasBudget G rho) (hG : G 0=1) :
    theta (M+b)/Real.log X≤(Real.log Y/Real.log X)*divisorSum X G M (fun _ => b)^2 := by
  by_cases hp : Nat.Prime (M+b)
  · rw [divisorSum_singleton_at_prime hX hM hp G hrho hbudget,hG,one_pow,mul_one]
    exact theta_div_log_le_upper hX hY hYP
  · rw [theta,ite_eq_right hp,zero_div]
    exact mul_nonneg (div_nonneg (Real.log_nonneg (by exact_mod_cast hYP))
      (log_pos_of_two_le hX).le) (sq_nonneg _)

theorem sum_square_diagonal_offdiag {α : Type*} [DecidableEq α]
    (B : Finset α) (f : α → ℝ) :
    (∑ b∈B,f b)^2=(∑ b∈B,f b^2)+∑ b∈B,∑ c∈B.erase b,f b*f c := by
  rw [pow_two,Finset.sum_mul_sum,←Finset.sum_add_distrib]
  apply Finset.sum_congr rfl
  intro b hb
  rw [←Finset.sum_erase_add B (fun c => f b*f c) hb]
  ring

theorem detector_square_majorant {X M Y : ℕ} (hX : 2≤X) (hYP : 1≤Y)
    (B : Finset ℕ) (hM : ∀ b∈B, X<M+b) (hY : ∀ b∈B, M+b≤Y)
    (G : (Fin 1 → ℝ) → ℝ) {rho : ℝ}
    (hrho : rho<1) (hbudget : HasBudget G rho) (hG : G 0=1) :
    detector X B M^2≤(Real.log Y/Real.log X)*detector X B M+
      (Real.log Y/Real.log X)^2*∑ b∈B,∑ c∈B.erase b,
        divisorSum X G M (fun _ => b)^2*divisorSum X G M (fun _ => c)^2 := by
  classical
  let t := fun b => theta (M+b)/Real.log X
  let q := Real.log Y/Real.log X
  let D := fun b => divisorSum X G M (fun _ => b)
  have ht (b : ℕ) : 0≤t b := div_nonneg (theta_nonneg _) (log_pos_of_two_le hX).le
  have hq : 0≤q := div_nonneg (Real.log_nonneg (by exact_mod_cast hYP)) (log_pos_of_two_le hX).le
  have he : detector X B M=∑ b∈B,t b := by rw [detector,Finset.sum_div]
  have hupper (b : ℕ) (hb : b∈B) : t b≤q := theta_div_log_le_upper hX (hY b hb) hYP
  have hmajor (b : ℕ) (hb : b∈B) : t b≤q*(D b)^2 :=
    singleton_divisor_majorant hX (hM b hb) (hY b hb) hYP G hrho hbudget hG
  rw [he,sum_square_diagonal_offdiag,Finset.mul_sum,Finset.mul_sum]
  apply add_le_add
  · apply Finset.sum_le_sum
    intro b hb
    simpa only [pow_two] using mul_le_mul_of_nonneg_right (hupper b hb) (ht b)
  · apply Finset.sum_le_sum
    intro b hb
    rw [Finset.mul_sum]
    apply Finset.sum_le_sum
    intro c hc
    have hcB := Finset.mem_of_mem_erase hc
    have hh := mul_le_mul (hmajor b hb) (hmajor c hcB) (ht c)
      (mul_nonneg hq (sq_nonneg (D b)))
    dsimp [q,D] at hh
    nlinarith

noncomputable def patternBoxShifts {n s h : ℕ} (p : Fin n → Fin s)
    (a : Fin s → ℕ) (u : Fin s → Fin h) : Fin n → ℕ :=
  fun i => a (p i)+(u (p i):ℕ)

theorem patternBoxShifts_family {n s h : ℕ} (p : Fin n → Fin s)
    (a : Fin s → ℕ) (u : Fin s → Fin h)
    (hu : u∈distinctBox (fun j => (a j:ℤ))) :
    shiftFamily (fun i => (patternBoxShifts p a u i:ℤ))=
      shiftFamily (fun i => ((p i).val:ℤ)) := by
  apply shiftFamily_eq_of_ker
  apply Setoid.ext
  intro i j
  have hi := (Finset.mem_filter.mp hu).2
  change ((patternBoxShifts p a u i:ℤ)=(patternBoxShifts p a u j:ℤ)) ↔
    ((p i).val:ℤ)=((p j).val:ℤ)
  have he (i : Fin n) : (patternBoxShifts p a u i:ℤ)=boxTuple (fun j => (a j:ℤ)) u (p i) := by
    simp only [patternBoxShifts,boxTuple,Nat.cast_add]
  rw [he,he,hi.eq_iff]
  constructor
  · intro h; rw [h]
  · intro h; apply Fin.ext; exact_mod_cast h

theorem patternBoxShifts_image {n s h : ℕ} (p : Fin n → Fin s)
    (hp : Function.Surjective p) (a : Fin s → ℕ) (u : Fin s → Fin h) :
    (Finset.univ.image fun i => (patternBoxShifts p a u i:ℤ))=
      Finset.univ.image (boxTuple (fun j => (a j:ℤ)) u) := by
  classical
  ext x
  simp only [Finset.mem_image,Finset.mem_univ,true_and]
  constructor
  · rintro ⟨i,rfl⟩
    exact ⟨p i,by simp only [boxTuple,patternBoxShifts,Nat.cast_add]⟩
  · rintro ⟨j,rfl⟩
    obtain ⟨i,rfl⟩ := hp j
    exact ⟨i,by simp only [boxTuple,patternBoxShifts,Nat.cast_add]⟩

theorem surjective_shiftFamily_sign_sum {n s : ℕ} (p : Fin n → Fin s)
    (hp : Function.Surjective p) :
    (∑ S∈shiftFamily (fun i => ((p i).val:ℤ)),(-1:ℤ)^S.card)=-(s:ℤ) := by
  classical
  rw [shiftFamily_sign_sum]
  have he : (Finset.univ.image fun i => ((p i).val:ℤ))=
      Finset.univ.image (fun j : Fin s => (j.val:ℤ)) := by
    ext x
    simp only [Finset.mem_image,Finset.mem_univ,true_and]
    constructor
    · rintro ⟨i,rfl⟩; exact ⟨p i,rfl⟩
    · rintro ⟨j,rfl⟩; obtain ⟨i,rfl⟩ := hp j; exact ⟨i,rfl⟩
  rw [he,Finset.card_image_of_injective]
  · simp only [Finset.card_univ,Fintype.card_fin]
  · intro i j hij; apply Fin.ext; exact_mod_cast (show (i.val:ℤ)=(j.val:ℤ) from hij)

theorem box_sum_scaled_norm_le {s h : ℕ} (a : Fin s → ℤ)
    (f g : (Fin s → Fin h) → ℂ) {L E : ℝ} (hL : 0<L) (hE : 0≤E)
    (herr : ∀ u∈distinctBox a, ‖(L:ℂ)^s*f u-g u‖≤E) :
    ‖(∑ u∈distinctBox a,f u)-(∑ u∈distinctBox a,g u)/(L:ℂ)^s‖≤((h:ℝ)/L)^s*E := by
  classical
  have hb : ‖∑ u∈distinctBox a,((L:ℂ)^s*f u-g u)‖≤(h:ℝ)^s*E := by
    calc
      _ ≤ ∑ _u∈distinctBox (h:=h) a,E := norm_sum_le_of_le _ herr
      _ = ((distinctBox (h:=h) a).card:ℝ)*E := by simp
      _ ≤ (h:ℝ)^s*E := by
        apply mul_le_mul_of_nonneg_right _ hE
        have hc := Finset.card_le_card (show distinctBox (h:=h) a⊆Finset.univ from Finset.subset_univ _)
        simpa only [Finset.card_univ,Fintype.card_fun,Fintype.card_fin,Nat.cast_pow] using
          (show ((distinctBox (h:=h) a).card:ℝ)≤(Fintype.card (Fin s → Fin h):ℝ) from by exact_mod_cast hc)
  rw [Finset.sum_sub_distrib,←Finset.mul_sum] at hb
  have hLc : (L:ℂ)≠0 := by exact_mod_cast ne_of_gt hL
  have he : (∑ u∈distinctBox a,f u)-(∑ u∈distinctBox a,g u)/(L:ℂ)^s=
      ((L:ℂ)^s*(∑ u∈distinctBox a,f u)-∑ u∈distinctBox a,g u)/(L:ℂ)^s := by
    field_simp [hLc]
  rw [he,norm_div,norm_pow,Complex.norm_real,Real.norm_eq_abs,abs_of_pos hL]
  apply (div_le_iff₀ (pow_pos hL _)).mpr
  apply le_trans hb
  apply le_of_eq
  rw [div_pow]
  field_simp

theorem box_sum_errors_tendsto_zero (s : ℕ) (H : ℕ → ℕ) (a : ℕ → Fin s → ℤ)
    (L E : ℕ → ℝ) (lam : ℝ)
    (f g : (X : ℕ) → (Fin s → Fin (H X)) → ℂ)
    (hL : ∀ᶠ X in atTop,0<L X)
    (hHL : Tendsto (fun X => (H X:ℝ)/L X) atTop (𝓝 lam))
    (hE : Tendsto E atTop (𝓝 0))
    (herr : ∀ᶠ X in atTop, ∀ u∈distinctBox (a X),‖(L X:ℂ)^s*f X u-g X u‖≤E X) :
    Tendsto (fun X => (∑ u∈distinctBox (a X),f X u)-
      (∑ u∈distinctBox (a X),g X u)/(L X:ℂ)^s) atTop (𝓝 0) := by
  apply squeeze_zero_norm' (a:=fun X => ((H X:ℝ)/L X)^s*|E X|)
  · filter_upwards [hL,herr] with X hLX hX
    exact box_sum_scaled_norm_le (a X) (f X) (g X) hLX (abs_nonneg _) (fun u hu =>
      (hX u hu).trans (le_abs_self _))
  · simpa only [abs_zero,mul_zero] using (hHL.pow s).mul hE.abs

theorem natural_boxDiameterBound {s h K : ℕ} (a : Fin s → ℕ) (ha : ∀ j,a j≤K*h) :
    boxDiameterBound (h:=h) (fun j => (a j:ℤ)) ((K+1)*h) := by
  intro u i j
  dsimp [boxTuple]
  have hi := (u i).isLt
  have hj := (u j).isLt
  have hai := ha i
  have haj := ha j
  have hk : K*h+h=(K+1)*h := by ring
  omega

theorem unmarked_box_pattern_limit {n s K : ℕ} {lam : ℝ} (hlam : 0<lam)
    (p : Fin (n+1) → Fin s) (hp : Function.Surjective p)
    (a : ℕ → Fin s → ℕ)
    (ha : ∀ᶠ X : ℕ in atTop, ∀ j,a X j≤K*blockLength lam X)
    (F : (Fin (n+1) → ℝ) → ℝ) (rho : ℝ)
    (hrho : 0≤rho) (hrho1 : rho<1) (hbudget : HasBudget F rho)
    (hF : HasCompactSupport (fun v : EuclideanSpace ℝ (Fin (n+1)) => (F v.ofLp:ℂ)))
    (hFs : ContDiff ℝ ∞ (fun v : EuclideanSpace ℝ (Fin (n+1)) => (F v.ofLp:ℂ)))
    (M : ℝ) (hM : 0≤M) (hbound : ∀ v, (∀ i,0≤v i) → |F v|≤M) :
    Tendsto (fun X : ℕ => ∑ u∈distinctBox (h:=blockLength lam X) (fun j => (a X j:ℤ)),
      (average X (fun m => divisorSum X F m (patternBoxShifts p (a X) u)):ℂ)) atTop
      (𝓝 ((lam:ℂ)^s*kernelConstant
        (sourceFourier (fourierCoordinateSum (Fin (n+1)))
          (fun v => (F v.ofLp:ℂ)) hF hFs) (shiftFamily (fun i => ((p i).val:ℤ))))) := by
  classical
  let B := shiftFamily (fun i => ((p i).val:ℤ))
  let c := kernelConstant (sourceFourier (fourierCoordinateSum (Fin (n+1)))
    (fun v => (F v.ofLp:ℂ)) hF hFs) B
  let H := blockLength lam
  let az := fun X j => (a X j:ℤ)
  let f := fun X (u : Fin s → Fin (H X)) =>
    (average X (fun m => divisorSum X F m (patternBoxShifts p (a X) u)):ℂ)
  let g := fun X (u : Fin s → Fin (H X)) =>
    (singularSeries (Finset.univ.image (boxTuple (az X) u)):ℂ)*c
  obtain ⟨E,hE,herr⟩ := unmarked_average_uniform_asymptotic F rho hrho hrho1 hbudget
    hF hFs M hM hbound B (shiftFamily_nonempty _) s 2 (by omega)
    (surjective_shiftFamily_sign_sum p hp)
  have herror : ∀ᶠ X in atTop, ∀ u∈distinctBox (az X),
      ‖(Real.log X:ℂ)^s*f X u-g X u‖≤E X := by
    filter_upwards [herr,ha,blockLength_densityCutoff_eventually hlam.le (2*(K+1))]
      with X hX haX hcut
    intro u hu
    have hb (i : Fin (n+1)) : patternBoxShifts p (a X) u i≤(K+1)*H X := by
      have hi := (u (p i)).isLt
      have hh := haX (p i)
      dsimp [H] at hi
      dsimp [patternBoxShifts,H]
      rw [Nat.add_mul,one_mul]
      omega
    have hz := hX (patternBoxShifts p (a X) u) (patternBoxShifts_family p (a X) u hu)
       ((K+1)*H X) hb (by simpa only [Nat.mul_assoc] using hcut)
    rw [patternBoxShifts_image p hp] at hz
    exact hz
  have hL : ∀ᶠ X : ℕ in atTop,0<Real.log X := by
    filter_upwards [eventually_ge_atTop 2] with X hX
    exact log_pos_of_two_le hX
  have hHL := blockLength_ratio_tendsto hlam.le
  have he := box_sum_errors_tendsto_zero s H az (fun X => Real.log X) E lam f g hL hHL hE herror
  have hmean : Tendsto (fun X => singularBoxMean (h:=H X) (az X)) atTop (𝓝 1) := by
    apply uniform_singularBoxMean_tendsto s (K:=K+1) (by omega) H az (blockLength_tendsto hlam)
    filter_upwards [ha] with X hX
    exact natural_boxDiameterBound (a X) hX
  have hmain : Tendsto (fun X => (∑ u∈distinctBox (az X),g X u)/(Real.log X:ℂ)^s)
      atTop (𝓝 ((lam:ℂ)^s*c)) := by
    have hh := ((Complex.continuous_ofReal.continuousAt.tendsto.comp hHL).pow s).mul
      (Complex.continuous_ofReal.continuousAt.tendsto.comp hmean)
    have hh' := hh.mul_const c
    simp only [Complex.ofReal_one,mul_one] at hh'
    apply hh'.congr'
    filter_upwards [hL,(blockLength_tendsto hlam).eventually_ge_atTop 1] with X hLX hHX
    have hHC : ((H X:ℕ):ℂ)≠0 := by exact_mod_cast (show H X≠0 by dsimp [H]; omega)
    have hLC : (Real.log X:ℂ)≠0 := by exact_mod_cast ne_of_gt hLX
    change (((H X:ℝ)/(Real.log X):ℝ):ℂ)^s * (singularBoxMean (h:=H X) (az X):ℂ)*c =
      (∑ u∈distinctBox (az X),g X u)/(Real.log X:ℂ)^s
    simp only [g,←Finset.sum_mul,←Complex.ofReal_sum,singularBoxMean,
      Complex.ofReal_div,Complex.ofReal_pow,Complex.ofReal_natCast]
    rw [div_pow]
    field_simp
  have h := he.add hmain
  simp only [sub_add_cancel,zero_add] at h
  exact h

theorem average_mono {X : ℕ} (f g : ℕ → ℝ)
    (h : ∀ m∈Finset.Ioc X (2*X),f m≤g m) : average X f≤average X g := by
  exact div_le_div_of_nonneg_right (Finset.sum_le_sum h) (Nat.cast_nonneg X)

theorem average_add (X : ℕ) (f g : ℕ → ℝ) :
    average X (fun m => f m+g m)=average X f+average X g := by
  rw [average,Finset.sum_add_distrib,add_div]
  rfl

theorem average_const_mul (X : ℕ) (c : ℝ) (f : ℕ → ℝ) :
    average X (fun m => c*f m)=c*average X f := by
  simp only [average,←Finset.mul_sum,mul_div_assoc]

theorem average_finset_sum {α : Type*} (X : ℕ) (S : Finset α) (f : α → ℕ → ℝ) :
    average X (fun m => ∑ i∈S,f i m)=∑ i∈S,average X (f i) := by
  unfold average
  rw [Finset.sum_comm,Finset.sum_div]

theorem weighted_detector_square_majorant {X Y : ℕ} (hX : 2≤X) (hYP : 1≤Y)
    (B : Finset ℕ) (hM : ∀ m ∈ Finset.Ioc X (2*X), ∀ b ∈ B, X < m+b)
    (hY : ∀ m ∈ Finset.Ioc X (2*X), ∀ b ∈ B, m+b ≤ Y)
    (W : ℕ → ℝ) (hW : ∀ m∈Finset.Ioc X (2*X),0≤W m)
    (G : (Fin 1 → ℝ) → ℝ) {rho : ℝ}
    (hrho : rho<1) (hbudget : HasBudget G rho) (hG : G 0=1) :
    average X (fun m => W m*detector X B m^2)≤
      (Real.log Y/Real.log X)*average X (fun m => W m*detector X B m)+
      (Real.log Y/Real.log X)^2*∑ b∈B,∑ c∈B.erase b,
        average X (fun m => W m*divisorSum X G m (fun _ => b)^2*
          divisorSum X G m (fun _ => c)^2) := by
  classical
  have hh := average_mono (X:=X) (fun m => W m*detector X B m^2)
    (fun m => W m*((Real.log Y/Real.log X)*detector X B m+
      (Real.log Y/Real.log X)^2*∑ b∈B,∑ c∈B.erase b,
        divisorSum X G m (fun _ => b)^2*divisorSum X G m (fun _ => c)^2)) (by
      intro m hm
      exact mul_le_mul_of_nonneg_left (detector_square_majorant hX hYP B
        (hM m hm) (hY m hm) G hrho hbudget hG) (hW m hm))
  have he : (fun m => W m*((Real.log Y/Real.log X)*detector X B m+
      (Real.log Y/Real.log X)^2*∑ b∈B,∑ c∈B.erase b,
        divisorSum X G m (fun _ => b)^2*divisorSum X G m (fun _ => c)^2))=
      (fun m => (Real.log Y/Real.log X)*(W m*detector X B m)+
        (Real.log Y/Real.log X)^2*(∑ b∈B,∑ c∈B.erase b,
          W m*divisorSum X G m (fun _ => b)^2*divisorSum X G m (fun _ => c)^2)) := by
    funext m
    have hs : (∑ b∈B,∑ c∈B.erase b,
        W m*divisorSum X G m (fun _ => b)^2*divisorSum X G m (fun _ => c)^2)=
        W m*(∑ b∈B,∑ c∈B.erase b,
          divisorSum X G m (fun _ => b)^2*divisorSum X G m (fun _ => c)^2) := by
      simp only [Finset.mul_sum,mul_assoc]
    rw [hs]
    ring
  rw [he,average_add,average_const_mul,average_const_mul,
    average_finset_sum] at hh
  simpa only [average_finset_sum] using hh

theorem detector_log_ratio_tendsto {lam : ℝ} (hlam : 0≤lam) :
    Tendsto (fun X : ℕ => Real.log (2*X+2*blockLength lam X)/Real.log X) atTop (𝓝 1) := by
  have hlog : Tendsto (fun X : ℕ => Real.log (X:ℝ)) atTop atTop :=
    Real.tendsto_log_atTop.comp tendsto_natCast_atTop_atTop
  have hinv : Tendsto (fun X : ℕ => (Real.log (X:ℝ))⁻¹) atTop (𝓝 0) :=
    tendsto_inv_atTop_zero.comp hlog
  have hH : Tendsto (fun X : ℕ => (blockLength lam X:ℝ)/(X:ℝ)) atTop (𝓝 0) := by
    have hlogratio : Tendsto (fun X : ℕ => Real.log (X:ℝ)/(X:ℝ)) atTop (𝓝 0) :=
      Real.isLittleO_log_id_atTop.tendsto_div_nhds_zero.comp tendsto_natCast_atTop_atTop
    apply squeeze_zero' (Eventually.of_forall (fun X => div_nonneg (Nat.cast_nonneg _) (Nat.cast_nonneg _)))
    · filter_upwards [eventually_ge_atTop 2] with X hX
      exact div_le_div_of_nonneg_right (blockLength_le_mul_log hlam hX) (Nat.cast_nonneg X)
    · simpa only [mul_div_assoc,mul_zero] using hlogratio.const_mul lam
  have harg : Tendsto (fun X : ℕ => 2+2*(blockLength lam X:ℝ)/(X:ℝ)) atTop (𝓝 2) := by
    simpa only [mul_zero,add_zero,mul_div_assoc] using tendsto_const_nhds.add (hH.const_mul 2)
  have hh := ((Real.continuousAt_log (by norm_num : (2:ℝ)≠0)).tendsto.comp harg).mul hinv
  have hh' := (tendsto_const_nhds (x := (1:ℝ))).add hh
  simp only [mul_zero,add_zero] at hh'
  apply hh'.congr'
  filter_upwards [eventually_ge_atTop 2] with X hX
  have hXP : 0<(X:ℝ) := by exact_mod_cast (show 0<X by omega)
  have hL := log_pos_of_two_le hX
  have hA : 0<2+2*(blockLength lam X:ℝ)/(X:ℝ) := by positivity
  have he : (2*(X:ℝ)+2*blockLength lam X)=(X:ℝ)*(2+2*(blockLength lam X:ℝ)/(X:ℝ)) := by
    field_simp
  simp only [Function.comp_apply]
  rw [he,Real.log_mul hXP.ne' hA.ne',add_div,div_self hL.ne']
  rfl

theorem exists_normalized_singleton_profile {tau : ℝ} (htau : 0<tau) :
    ∃ f : (Fin 1 → ℝ) → ℝ, ContDiff ℝ ∞ f ∧ HasCompactSupport f ∧
      tsupport f⊆positiveSimplex 1 tau ∧ (∀ v,0≤f v) ∧ (∫ v,f v)=1 := by
  have hopen : IsOpen (positiveSimplex 1 tau) := by
    have he : positiveSimplex 1 tau=(fun v : Fin 1 → ℝ => v 0) ⁻¹' Ioo 0 tau := by
      ext v
      simp [positiveSimplex,coordinateSum,Fin.forall_fin_one]
    rw [he]
    exact isOpen_Ioo.preimage (continuous_apply 0)
  have hmem : (fun _ : Fin 1 => tau/2)∈positiveSimplex 1 tau := by
    simp only [positiveSimplex,Set.mem_ofPred_eq,coordinateSum,Fin.sum_univ_one]
    constructor
    · intro i; positivity
    · linarith
  obtain ⟨f,hs,hc,hf,h01,h1⟩ := exists_contDiff_tsupport_subset (n:=(⊤:ℕ∞)) (hopen.mem_nhds hmem)
  have hn : ∀ v,0≤f v := fun v => (h01 (Set.mem_range_self v)).1
  let A := ∫ v,f v
  have hA : 0<A := integral_pos_of_integrable_nonneg_nonzero hf.continuous
    (hf.continuous.integrable_of_hasCompactSupport hc) hn (by rw [h1]; norm_num)
  let g := fun v => f v/A
  have hgc : HasCompactSupport g := hc.comp_left (g:=fun x : ℝ => x/A) (by simp)
  have hgs : tsupport g⊆positiveSimplex 1 tau :=
    (tsupport_comp_subset (g:=fun x : ℝ => x/A) (by simp) f).trans hs
  refine ⟨g,hf.div_const A,hgc,hgs,fun v => div_nonneg (hn v) hA.le,?_⟩
  rw [show g=(fun v => f v/A) from rfl,integral_div]
  exact div_self hA.ne'

theorem exists_detector_profile {tau : ℝ} (htau : 0<tau) :
    ∃ f : (Fin 1 → ℝ) → ℝ, ContDiff ℝ ∞ f ∧ HasCompactSupport f ∧
      tsupport f⊆positiveSimplex 1 tau ∧
      HasBudget (cumulativeProfile tau f) tau ∧
      ContDiff ℝ ∞ (cumulativeProfile tau f) ∧
      HasCompactSupport (cumulativeProfile tau f) ∧
      cumulativeProfile tau f 0=1 := by
  obtain ⟨f,hf,hc,hs,_hn,h1⟩ := exists_normalized_singleton_profile htau
  refine ⟨f,hf,hc,hs,cumulativeProfile_budget tau f hs,
    cumulativeProfile_smooth tau f hc hf,cumulativeProfile_compact tau f hc,?_⟩
  rw [cumulativeProfile_tail tau f hs 0 (fun _ => le_rfl)]
  rw [setIntegral_eq_integral_of_forall_compl_eq_zero,h1]
  intro v hv
  by_contra hne
  apply hv
  intro i
  exact (hs (subset_tsupport f hne)).1 i |>.le

end LargePrimeGaps

end OAI