import OAI.NumberTheory.PrimeGaps.EulerProducts

namespace OAI

namespace LargePrimeGaps

open Filter

open Set Filter MeasureTheory

open scoped Topology ContDiff

open Asymptotics

open Asymptotics

open Asymptotics

open scoped Classical

section FourierNormalization

open scoped FourierTransform SchwartzMap

variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
  [FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V]

noncomputable def frequencyDilation : V ≃L[ℝ] V :=
  Units.mk0 ((2*Real.pi)⁻¹) (inv_ne_zero (by positivity)) • ContinuousLinearEquiv.refl ℝ V

omit [FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V] in
@[simp] theorem frequencyDilation_apply (u : V) :
    frequencyDilation u = (2*Real.pi)⁻¹ • u := rfl

noncomputable def radianFourier (G : SchwartzMap V ℂ) : SchwartzMap V ℂ :=
  (((2*Real.pi)^Module.finrank ℝ V)⁻¹ : ℝ) •
    SchwartzMap.compCLMOfContinuousLinearEquiv ℂ frequencyDilation (𝓕⁻ G)

theorem radianFourier_apply (G : SchwartzMap V ℂ) (u : V) :
    radianFourier G u = (((2*Real.pi)^Module.finrank ℝ V)⁻¹ : ℝ) •
      ∫ v : V, Complex.exp (Complex.I*(inner ℝ u v : ℂ))*G v := by
  simp only [radianFourier, smul_apply,
    SchwartzMap.compCLMOfContinuousLinearEquiv_apply, Function.comp_apply,
    frequencyDilation_apply, SchwartzMap.fourierInv_coe, Real.fourierInv_eq']
  congr 1
  apply integral_congr_ae
  filter_upwards [] with v
  rw [real_inner_smul_right, real_inner_comm v u]
  simp only [smul_eq_mul]
  congr 2
  push_cast
  field_simp

theorem radianFourier_inversion (G : SchwartzMap V ℂ) (v : V) :
    (∫ u : V, radianFourier G u * Complex.exp (-Complex.I*(inner ℝ u v : ℂ))) = G v := by
  let A : ℝ := 2*Real.pi
  have hA : 0<A := by dsimp [A]; positivity
  let f := fun u : V => (𝓕⁻ G) u * Complex.exp (-Complex.I*((A*inner ℝ u v : ℝ):ℂ))
  have hscale : (∫ u : V, f (A⁻¹ • u)) = A^Module.finrank ℝ V • ∫ u : V, f u := by
    simpa only [inv_pow, inv_inv] using Measure.integral_comp_smul_of_nonneg volume f A⁻¹ (hR:= (inv_pos.mpr hA).le)
  have hinv : (∫ u : V, f u) = G v := by
    have hh := congrArg (fun H : SchwartzMap V ℂ => H v) (FourierTransform.fourier_fourierInv_eq (F := SchwartzMap V ℂ) G)
    rw [SchwartzMap.fourier_coe, Real.fourier_eq'] at hh
    convert hh using 1
    apply integral_congr_ae
    filter_upwards [] with u
    dsimp only [f, A]
    rw [smul_eq_mul, mul_comm]
    congr 2
    push_cast
    ring_nf
  calc
    _ = ∫ u : V, (A^Module.finrank ℝ V)⁻¹ • f (A⁻¹ • u) := by
      apply integral_congr_ae
      filter_upwards [] with u
      simp only [radianFourier, smul_apply,
        SchwartzMap.compCLMOfContinuousLinearEquiv_apply, Function.comp_apply,
        frequencyDilation_apply]
      dsimp only [f, A]
      rw [real_inner_smul_left]
      have ht : 2*Real.pi*((2*Real.pi)⁻¹*inner ℝ u v) = inner ℝ u v := by field_simp
      rw [ht]
      simp only [Complex.real_smul, mul_assoc]
    _ = (A^Module.finrank ℝ V)⁻¹ • ∫ u : V, f (A⁻¹ • u) := integral_smul _ _
    _ = (A^Module.finrank ℝ V)⁻¹ • (A^Module.finrank ℝ V • G v) := by rw [hscale, hinv]
    _ = G v := by rw [smul_smul, inv_mul_cancel₀ (pow_ne_zero _ hA.ne'), one_smul]

noncomputable def laplaceSchwartz (ℓ : V →L[ℝ] ℝ) (F : V → ℂ)
    (hF : HasCompactSupport F) (hFs : ContDiff ℝ ∞ F) : SchwartzMap V ℂ :=
  (show HasCompactSupport (fun v => Complex.exp (ℓ v : ℂ)*F v) from hF.mul_left).toSchwartzMap
    (((Complex.ofRealCLM.contDiff.comp ℓ.contDiff).cexp).mul hFs)

omit [FiniteDimensional ℝ V] [MeasurableSpace V] [BorelSpace V] in
@[simp] theorem laplaceSchwartz_apply (ℓ : V →L[ℝ] ℝ) (F : V → ℂ)
    (hF : HasCompactSupport F) (hFs : ContDiff ℝ ∞ F) (v : V) :
    laplaceSchwartz ℓ F hF hFs v = Complex.exp (ℓ v : ℂ)*F v := rfl

noncomputable def sourceFourier (ℓ : V →L[ℝ] ℝ) (F : V → ℂ)
    (hF : HasCompactSupport F) (hFs : ContDiff ℝ ∞ F) : SchwartzMap V ℂ :=
  radianFourier (laplaceSchwartz ℓ F hF hFs)

theorem sourceFourier_apply (ℓ : V →L[ℝ] ℝ) (F : V → ℂ)
    (hF : HasCompactSupport F) (hFs : ContDiff ℝ ∞ F) (u : V) :
    sourceFourier ℓ F hF hFs u = (((2*Real.pi)^Module.finrank ℝ V)⁻¹ : ℝ) •
      ∫ v : V, Complex.exp (ℓ v : ℂ)*F v*Complex.exp (Complex.I*(inner ℝ u v : ℂ)) := by
  rw [sourceFourier, radianFourier_apply]
  congr 1
  apply integral_congr_ae
  filter_upwards [] with v
  rw [laplaceSchwartz_apply]
  ring_nf

theorem sourceFourier_inversion (ℓ : V →L[ℝ] ℝ) (F : V → ℂ)
    (hF : HasCompactSupport F) (hFs : ContDiff ℝ ∞ F) (v : V) :
    (∫ u : V, sourceFourier ℓ F hF hFs u *
      Complex.exp (-(ℓ v : ℂ)-Complex.I*(inner ℝ u v : ℂ))) = F v := by
  calc
    _ = Complex.exp (-(ℓ v : ℂ)) *
        ∫ u : V, sourceFourier ℓ F hF hFs u *
          Complex.exp (-Complex.I*(inner ℝ u v : ℂ)) := by
      rw [← integral_const_mul]
      apply integral_congr_ae
      filter_upwards [] with u
      rw [sub_eq_add_neg, Complex.exp_add]
      ring_nf
    _ = Complex.exp (-(ℓ v : ℂ)) * (Complex.exp (ℓ v : ℂ)*F v) := by
      rw [sourceFourier, radianFourier_inversion, laplaceSchwartz_apply]
    _ = F v := by rw [← mul_assoc, ← Complex.exp_add]; simp

theorem sourceFourier_integrable_pow_mul (ℓ : V →L[ℝ] ℝ) (F : V → ℂ)
    (hF : HasCompactSupport F) (hFs : ContDiff ℝ ∞ F) (k : ℕ) :
    Integrable (fun u : V => ‖u‖^k*‖sourceFourier ℓ F hF hFs u‖) :=
  SchwartzMap.integrable_pow_mul volume _ k

end FourierNormalization

def primePrefix (y : ℕ) : Finset Nat.Primes := (Nat.primesLE y).subtype Nat.Prime

@[simp] theorem mem_primePrefix (y : ℕ) (p : Nat.Primes) :
    p∈primePrefix y ↔ (p:ℕ)≤y := by
  exact (Finset.mem_subtype (p := Nat.Prime) (s := Nat.primesLE y) (a := p)).trans
    (by rw [Nat.mem_primesLE]; exact and_iff_left p.property)

noncomputable def eulerGlobal {ι : Type*} (δ : ℕ) (A : ℕ → Finset (Finset ι))
    (B : Finset (Finset ι)) (z : ι → ℂ) : ℂ :=
  ∏' p : Nat.Primes, eulerH p δ (A p) B z

noncomputable def genericEulerConstant (m : ℕ) : ℝ :=
  (1+m)*(4*(m:ℝ)^2*2^m+2*m)+2*m+2*(m:ℝ)^2

theorem genericEulerConstant_nonneg (m : ℕ) : 0≤genericEulerConstant m := by
  unfold genericEulerConstant
  positivity

theorem eulerH_summable_error {ι : Type*} {δ : ℕ} (hδ : δ≤1)
    (A : ℕ → Finset (Finset ι)) (B : Finset (Finset ι))
    (z : ι → ℂ) (hz : ∀ i, 0≤(z i).re) {y : ℕ} (hy : 0<y)
    (hgen : ∀ p : Nat.Primes, y<(p:ℕ) → A p=B) :
    Summable (fun p : Nat.Primes => ‖eulerH p δ (A p) B z-1‖) := by
  apply (primePrefix y).summable_compl_iff.mp
  apply (summable_tsum_le_of_reciprocal_sq
    (fun p : {p : Nat.Primes // p∉primePrefix y} => (p.val:ℕ))
    (fun _ _ he => Subtype.ext (Subtype.ext he)) hy
    (fun p => by have := p.property; simp only [mem_primePrefix, not_le] at this; exact this)
    (fun p => ‖eulerH p.val δ (A p.val) B z-1‖)
    (genericEulerConstant_nonneg B.card) (fun _ => norm_nonneg _) ?_).1
  intro p
  have hp : y<(p.val:ℕ) := by
    have := p.property
    simpa only [mem_primePrefix, not_le] using this
  rw [hgen p.val hp]
  exact eulerH_generic_error p.val.property.two_le hδ B z (fun _ _ i _ => hz i)

theorem eulerH_tail_sum {ι : Type*} {δ : ℕ} (hδ : δ≤1)
    (A : ℕ → Finset (Finset ι)) (B : Finset (Finset ι))
    (z : ι → ℂ) (hz : ∀ i, 0≤(z i).re) {y : ℕ} (hy : 0<y)
    (hgen : ∀ p : Nat.Primes, y<(p:ℕ) → A p=B) :
    (∑' p : {p : Nat.Primes // p∉primePrefix y}, ‖eulerH p.val δ (A p.val) B z-1‖) ≤
      genericEulerConstant B.card/(y:ℝ) := by
  apply (summable_tsum_le_of_reciprocal_sq
    (fun p : {p : Nat.Primes // p∉primePrefix y} => (p.val:ℕ))
    (fun _ _ he => Subtype.ext (Subtype.ext he)) hy
    (fun p => by have := p.property; simp only [mem_primePrefix, not_le] at this; exact this)
    (fun p => ‖eulerH p.val δ (A p.val) B z-1‖)
    (genericEulerConstant_nonneg B.card) (fun _ => norm_nonneg _) ?_).2
  intro p
  have hp : y<(p.val:ℕ) := by
    have := p.property
    simpa only [mem_primePrefix, not_le] using this
  rw [hgen p.val hp]
  exact eulerH_generic_error p.val.property.two_le hδ B z (fun _ _ i _ => hz i)

noncomputable def primeReciprocalPrefix (y : ℕ) : ℝ :=
  ∑ p∈primePrefix y, (p:ℝ)⁻¹

theorem eulerGlobal_comparison {ι : Type*} [Fintype ι] {δ : ℕ} (hδ : δ≤1)
    (A : ℕ → Finset (Finset ι)) (B : Finset (Finset ι))
    (z : ι → ℂ) (hz : ∀ i, 0≤(z i).re) {y R : ℕ} (hy : 2≤y)
    (hA : ∀ p : Nat.Primes, (A p).card≤R) (hB : B.card≤R)
    (hgen : ∀ p : Nat.Primes, y<(p:ℕ) → A p=B) :
    ‖eulerGlobal δ A B z-eulerGlobal δ A B (fun _ => 0)‖ ≤
      Real.exp (4*R*primeReciprocalPrefix y)*
        (Real.exp (2*R)*6*R*Real.log y*(∑ i, ‖z i‖)*primeReciprocalPrefix y+
          2*(Real.exp (genericEulerConstant B.card/(y:ℝ))-1)) := by
  let Z : ℝ := ∑ i, ‖z i‖
  have hZ : 0≤Z := Finset.sum_nonneg fun _ _ => norm_nonneg _
  have hy0 : 0<y := by omega
  have hyR : (0:ℝ)<y := by exact_mod_cast hy0
  have hly : 0≤Real.log (y:ℝ) := Real.log_nonneg (by exact_mod_cast (by omega : 1≤y))
  have hf := eulerH_summable_error hδ A B z hz hy0 hgen
  have hg := eulerH_summable_error hδ A B (fun _ => 0) (by simp) hy0 hgen
  let b : Nat.Primes → ℝ := fun p => Real.exp (4*R*(p:ℝ)⁻¹)
  let e : Nat.Primes → ℝ := fun p => Real.exp (2*R)*6*R*Real.log y*Z*(p:ℝ)⁻¹
  have hbn (p : Nat.Primes) : 1≤b p := Real.one_le_exp (by positivity)
  have hnorm (w : ι → ℂ) (hw : ∀ i, 0≤(w i).re) (p : Nat.Primes) :
      ‖eulerH p δ (A p) B w‖≤b p := by
    apply (norm_eulerH_le p.property.two_le hδ (A p) B w hw).trans
    apply Real.exp_le_exp.mpr
    have haR : ((A p).card:ℝ)≤R := by exact_mod_cast hA p
    have hbR : (B.card:ℝ)≤R := by exact_mod_cast hB
    have hp0 : 0≤(p:ℝ)⁻¹ := by positivity
    nlinarith
  have hd (p : Nat.Primes) (hp : p∈primePrefix y) :
      ‖eulerH p δ (A p) B z-eulerH p δ (A p) B (fun _ => 0)‖≤e p := by
    have haR : ((A p).card:ℝ)≤R := by exact_mod_cast hA p
    have hbR : (B.card:ℝ)≤R := by exact_mod_cast hB
    have hp0 : (0:ℝ)<p := by exact_mod_cast p.property.pos
    have hpl : 0≤Real.log (p:ℝ) := Real.log_nonneg (by exact_mod_cast p.property.one_le)
    have hpu : Real.log (p:ℝ)≤Real.log (y:ℝ) :=
      Real.log_le_log hp0 (by exact_mod_cast (mem_primePrefix y p).mp hp)
    have hp2 : (p:ℝ)⁻¹≤1/2 := prime_inv_le_half p.property.two_le
    have hpe : 2*((A p).card+B.card)*(p:ℝ)⁻¹≤2*R := by
      nlinarith [mul_nonneg (by positivity : (0:ℝ)≤R) (sub_nonneg.mpr hp2),
        mul_nonneg (show 0≤(p:ℝ)⁻¹ by positivity) (show (0:ℝ)≤2*R-((A p).card+B.card) by linarith)]
    have hpc : (2*(A p).card+4*B.card:ℝ)≤6*R := by linarith
    calc
      _ ≤ Real.exp (2*((A p).card+B.card)*(p:ℝ)⁻¹)*
          ((2*(A p).card+4*B.card)*(p:ℝ)⁻¹*Real.log p*Z) :=
        norm_eulerH_sub_zero_le p.property.two_le hδ (A p) B z hz
      _ ≤ Real.exp (2*R)*((6*R)*(p:ℝ)⁻¹*Real.log y*Z) := by gcongr
      _ = e p := by dsimp only [e]; ring
  have hh := norm_tprod_sub_tprod_le (primePrefix y) hf hg b e
    (fun p _ => hbn p) (fun p _ => hnorm z hz p)
    (fun p _ => hnorm (fun _ => 0) (by simp) p) hd
  have hbprod : (∏ p∈primePrefix y, b p) = Real.exp (4*R*primeReciprocalPrefix y) := by
    dsimp only [b, primeReciprocalPrefix]
    rw [← Real.exp_sum, Finset.mul_sum]
  have hesum : (∑ p∈primePrefix y, e p) =
      Real.exp (2*R)*6*R*Real.log y*Z*primeReciprocalPrefix y := by
    simp only [e, primeReciprocalPrefix, Finset.mul_sum]
  have htf := eulerH_tail_sum hδ A B z hz hy0 hgen
  have htg := eulerH_tail_sum hδ A B (fun _ => 0) (by simp) hy0 hgen
  rw [hbprod, hesum] at hh
  calc
    _ ≤ Real.exp (4*R*primeReciprocalPrefix y)*
        (Real.exp (2*R)*6*R*Real.log y*Z*primeReciprocalPrefix y+
          (Real.exp (genericEulerConstant B.card/(y:ℝ))-1)+
          (Real.exp (genericEulerConstant B.card/(y:ℝ))-1)) := by
      apply hh.trans
      gcongr
    _ = _ := by dsimp only [Z]; ring

theorem eq_of_emod_eq_of_bound {a b : ℤ} {D p : ℕ}
    (ha : a.natAbs≤D) (hb : b.natAbs≤D) (hp : 2*D<p)
    (hab : a%(p:ℤ)=b%(p:ℤ)) : a=b := by
  have hd : (p:ℤ)∣a-b := Int.dvd_of_emod_eq_zero
    (Int.emod_eq_emod_iff_emod_sub_eq_zero.mp hab)
  have hdN : p∣(a-b).natAbs := by
    simpa only [Int.natAbs_natCast] using Int.natAbs_dvd_natAbs.mpr hd
  have hlt : (a-b).natAbs<p := by have := Int.natAbs_sub_le a b; omega
  exact sub_eq_zero.mp (Int.natAbs_eq_zero.mp (Nat.eq_zero_of_dvd_of_lt hdN hlt))

theorem residueFamily_generic_of_bound {ι : Type*} [Fintype ι] (b : ι → ℤ)
    {D p : ℕ} (hb : ∀ i, (b i).natAbs≤D) (hp : 2*D<p) :
    residueFamily b p=shiftFamily b :=
  residueFamily_eq_shiftFamily b p (fun i j he => eq_of_emod_eq_of_bound (hb i) (hb j) hp he)

theorem markedResidueFamily_generic_of_bound {ι : Type*} [Fintype ι] (b : ι → ℤ)
    (a : ℤ) (ha : ∀ i, b i≠a) {D p : ℕ} (hb : ∀ i, (b i).natAbs≤D)
    (haD : a.natAbs≤D) (hp : 2*D<p) :
    markedResidueFamily b p a=shiftFamily b :=
  markedResidueFamily_eq_shiftFamily b p a
    (fun i j he => eq_of_emod_eq_of_bound (hb i) (hb j) hp he)
    (fun i he => ha i (eq_of_emod_eq_of_bound (hb i) haD hp he))

theorem subsetFamily_card_le {ι : Type*} [Fintype ι] (S : Finset (Finset ι)) :
    S.card≤2^Fintype.card ι := by
  classical
  simpa only [Fintype.card_finset] using Finset.card_le_univ S

theorem unmarked_eulerGlobal_comparison {ι : Type*} [Fintype ι]
    (b : ι → ℤ) (z : ι → ℂ) (hz : ∀ i, 0≤(z i).re)
    {D y : ℕ} (hy : 2≤y) (hb : ∀ i, (b i).natAbs≤D) (hyD : 2*D≤y) :
    ‖eulerGlobal 0 (residueFamily b) (shiftFamily b) z-
        eulerGlobal 0 (residueFamily b) (shiftFamily b) (fun _ => 0)‖ ≤
      Real.exp (4*(2^Fintype.card ι:ℕ)*primeReciprocalPrefix y)*
        (Real.exp (2*(2^Fintype.card ι:ℕ))*6*(2^Fintype.card ι:ℕ)*Real.log y*
          (∑ i, ‖z i‖)*primeReciprocalPrefix y+
          2*(Real.exp (genericEulerConstant (shiftFamily b).card/(y:ℝ))-1)) :=
  eulerGlobal_comparison (by omega) (residueFamily b) (shiftFamily b) z hz hy
    (fun _ => subsetFamily_card_le _) (subsetFamily_card_le _)
    (fun _ hp => residueFamily_generic_of_bound b hb (hyD.trans_lt hp))

theorem marked_eulerGlobal_comparison {ι : Type*} [Fintype ι]
    (b : ι → ℤ) (a : ℤ) (ha : ∀ i, b i≠a) (z : ι → ℂ) (hz : ∀ i, 0≤(z i).re)
    {D y : ℕ} (hy : 2≤y) (hb : ∀ i, (b i).natAbs≤D) (haD : a.natAbs≤D) (hyD : 2*D≤y) :
    ‖eulerGlobal 1 (fun p => markedResidueFamily b p a) (shiftFamily b) z-
        eulerGlobal 1 (fun p => markedResidueFamily b p a) (shiftFamily b) (fun _ => 0)‖ ≤
      Real.exp (4*(2^Fintype.card ι:ℕ)*primeReciprocalPrefix y)*
        (Real.exp (2*(2^Fintype.card ι:ℕ))*6*(2^Fintype.card ι:ℕ)*Real.log y*
          (∑ i, ‖z i‖)*primeReciprocalPrefix y+
          2*(Real.exp (genericEulerConstant (shiftFamily b).card/(y:ℝ))-1)) :=
  eulerGlobal_comparison (by omega) (fun p => markedResidueFamily b p a) (shiftFamily b) z hz hy
    (fun _ => subsetFamily_card_le _) (subsetFamily_card_le _)
    (fun _ hp => markedResidueFamily_generic_of_bound b a ha hb haD (hyD.trans_lt hp))

theorem singularSeries_cast_hasProd (H : Finset ℤ) :
    HasProd (fun p : Nat.Primes => (singularLocal H p : ℂ)) (singularSeries H : ℂ) := by
  exact (singularSeries_multipliable H).hasProd.map Complex.ofRealHom.toMonoidHom
    Complex.continuous_ofReal

theorem unmarked_eulerGlobal_zero {ι : Type*} [Fintype ι] (b : ι → ℤ) :
    eulerGlobal 0 (residueFamily b) (shiftFamily b) (fun _ => 0) =
      (singularSeries (Finset.univ.image b) : ℂ) := by
  rw [eulerGlobal]
  exact ((singularSeries_cast_hasProd _).congr_fun fun p =>
    eulerH_unmarked_zero b p.property.two_le).tprod_eq

theorem marked_eulerGlobal_zero {ι : Type*} [Fintype ι] (b : ι → ℤ) (a : ℤ)
    (ha : ∀ i, b i≠a) :
    eulerGlobal 1 (fun p => markedResidueFamily b p a) (shiftFamily b) (fun _ => 0) =
      (singularSeries (insert a (Finset.univ.image b)) : ℂ) := by
  rw [eulerGlobal]
  exact ((singularSeries_cast_hasProd _).congr_fun fun p =>
    eulerH_marked_zero b a ha p.property.two_le).tprod_eq

theorem primeMonomial_cpow {ι : Type*} {p : ℕ} (hp : 0<p)
    (z : ι → ℂ) (S : Finset ι) :
    (p:ℂ)^(-(1+∑ i∈S, z i)) = (p:ℂ)⁻¹*primeMonomial p z S := by
  have hp0 : (p:ℂ)≠0 := by exact_mod_cast hp.ne'
  rw [Complex.cpow_def_of_ne_zero hp0, ← Complex.natCast_log]
  rw [show (Real.log p : ℂ)*(-(1+∑ i∈S, z i)) =
    -(Real.log p : ℂ)+(-(Real.log p : ℂ)*(∑ i∈S, z i)) by ring,
    Complex.exp_add, Complex.exp_neg, Complex.natCast_log, Complex.exp_log hp0]
  simp only [primeMonomial, Complex.natCast_log]

noncomputable def eulerZetaProduct {ι : Type*} (B : Finset (Finset ι)) (z : ι → ℂ) : ℂ :=
  ∏ S∈B, riemannZeta (1+∑ i∈S, z i)^((-1:ℤ)^S.card)

theorem eulerZetaProduct_hasProd {ι : Type*} (B : Finset (Finset ι)) (z : ι → ℂ)
    (hB : ∀ S∈B, S.Nonempty) (hz : ∀ i, 0<(z i).re) :
    HasProd (fun p : Nat.Primes =>
      ∏ S∈B, (1-(p:ℂ)⁻¹*primeMonomial p z S)^(-((-1:ℤ)^S.card)))
      (eulerZetaProduct B z) := by
  apply hasProd_prod
  intro S hS
  have hs : 1<(1+∑ i∈S, z i).re := by
    simp only [Complex.add_re, Complex.one_re, Complex.re_sum]
    exact lt_add_of_pos_right _ (Finset.sum_pos (fun i _ => hz i) (hB S hS))
  have he := riemannZeta_eulerProduct_hasProd hs
  have hc (p : Nat.Primes) : (p:ℂ)^(-(1+∑ i∈S, z i)) =
      (p:ℂ)⁻¹*primeMonomial p z S := primeMonomial_cpow p.property.pos z S
  rcases sign_zpow_cases S.card with hp | hn
  · simpa only [hp, zpow_neg_one, zpow_one, hc] using he
  · have he' := he.inv₀ (riemannZeta_ne_zero_of_one_lt_re hs)
    simpa only [hn, neg_neg, zpow_one, zpow_neg_one, inv_inv, hc] using he'

theorem eulerZetaProduct_ne_zero {ι : Type*} (B : Finset (Finset ι)) (z : ι → ℂ)
    (hB : ∀ S∈B, S.Nonempty) (hz : ∀ i, 0<(z i).re) :
    eulerZetaProduct B z ≠ 0 := by
  apply Finset.prod_ne_zero_iff.mpr
  intro S hS
  apply zpow_ne_zero _
  apply riemannZeta_ne_zero_of_one_lt_re
  simp only [Complex.add_re, Complex.one_re, Complex.re_sum]
  exact lt_add_of_pos_right _ (Finset.sum_pos (fun i _ => hz i) (hB S hS))

theorem local_zeta_factor_ne_zero {ι : Type*} {p : ℕ} (hp : 2≤p)
    (z : ι → ℂ) (S : Finset ι) (hz : ∀ i∈S, 0≤(z i).re) :
    1-(p:ℂ)⁻¹*primeMonomial p z S ≠ 0 := by
  have hpR : (1:ℝ)<p := by exact_mod_cast (by omega : 1<p)
  have hb := (primeMonomial_scaled_norm (by omega) z S hz).trans_lt
    ((inv_lt_one₀ (by positivity : (0:ℝ)<p)).mpr hpR)
  intro he
  rw [← sub_eq_zero.mp he, norm_one] at hb
  exact hb.false

theorem eulerP_eq_eulerH_mul {ι : Type*} {p : ℕ} (hp : 2≤p) (δ : ℕ)
    (A B : Finset (Finset ι)) (z : ι → ℂ) (hz : ∀ i, 0≤(z i).re) :
    eulerP p δ A z = eulerH p δ A B z *
      ∏ S∈B, (1-(p:ℂ)⁻¹*primeMonomial p z S)^(-((-1:ℤ)^S.card)) := by
  rw [eulerH, mul_assoc, ← Finset.prod_mul_distrib]
  have he : (∏ S∈B, (1-(p:ℂ)⁻¹*primeMonomial p z S)^((-1:ℤ)^S.card) *
      (1-(p:ℂ)⁻¹*primeMonomial p z S)^(-((-1:ℤ)^S.card))) = 1 := by
    apply Finset.prod_eq_one
    intro S _
    rw [← zpow_add₀ (local_zeta_factor_ne_zero hp z S (fun i _ => hz i)), add_neg_cancel,
      zpow_zero]
  rw [he, mul_one]

theorem eulerP_hasProd {ι : Type*} (δ : ℕ)
    (A : ℕ → Finset (Finset ι)) (B : Finset (Finset ι)) (z : ι → ℂ)
    (hB : ∀ S∈B, S.Nonempty) (hz : ∀ i, 0<(z i).re) {H : ℂ}
    (hH : HasProd (fun p : Nat.Primes => eulerH p δ (A p) B z) H) :
    HasProd (fun p : Nat.Primes => eulerP p δ (A p) z) (H*eulerZetaProduct B z) := by
  exact (hH.mul (eulerZetaProduct_hasProd B z hB hz)).congr_fun fun p =>
    eulerP_eq_eulerH_mul p.property.two_le δ (A p) B z (fun i => (hz i).le)

abbrev EulerChoices {κ : Type*} (A : κ → Type*) :=
  Σ P : Finset κ, (p : P) → A p

noncomputable def eulerChoiceTerm {κ : Type*} {A : κ → Type*}
    (w : (p : κ) → A p → ℂ) (c : EulerChoices A) : ℂ :=
  ∏ p : c.1, w p (c.2 p)

noncomputable def eulerChoiceNorm {κ : Type*} [DecidableEq κ] {A : κ → Type*} [∀ p, Fintype (A p)]
    (w : (p : κ) → A p → ℂ) (p : κ) : ℝ := ∑ a, ‖w p a‖

theorem eulerChoiceNorm_nonneg {κ : Type*} [DecidableEq κ] {A : κ → Type*} [∀ p, Fintype (A p)]
    (w : (p : κ) → A p → ℂ) (p : κ) : 0≤eulerChoiceNorm w p :=
  Finset.sum_nonneg fun _ _ => norm_nonneg _

theorem eulerChoice_sum_norm {κ : Type*} [DecidableEq κ] {A : κ → Type*} [∀ p, Fintype (A p)]
    (w : (p : κ) → A p → ℂ) (P : Finset κ) :
    (∑ c : (p : P) → A p, ‖eulerChoiceTerm w ⟨P,c⟩‖) = ∏ p∈P, eulerChoiceNorm w p := by
  classical
  simp only [eulerChoiceTerm, norm_prod, eulerChoiceNorm]
  rw [← Fintype.prod_sum (fun (p : P) (a : A p) => ‖w p a‖)]
  exact Finset.prod_coe_sort P (fun p => ∑ a, ‖w p a‖)

theorem eulerChoice_sum {κ : Type*} [DecidableEq κ] {A : κ → Type*} [∀ p, Fintype (A p)]
    (w : (p : κ) → A p → ℂ) (P : Finset κ) :
    (∑ c : (p : P) → A p, eulerChoiceTerm w ⟨P,c⟩) = ∏ p∈P, ∑ a, w p a := by
  classical
  simp only [eulerChoiceTerm]
  rw [← Fintype.prod_sum (fun (p : P) (a : A p) => w p a)]
  exact Finset.prod_coe_sort P (fun p => ∑ a, w p a)

theorem eulerChoice_summable_norm {κ : Type*} [DecidableEq κ] {A : κ → Type*} [∀ p, Fintype (A p)]
    (w : (p : κ) → A p → ℂ) (hw : Summable (eulerChoiceNorm w)) :
    Summable (fun c : EulerChoices A => ‖eulerChoiceTerm w c‖) := by
  classical
  apply (summable_sigma_of_nonneg (fun _ => norm_nonneg _)).mpr
  refine ⟨fun _ => (hasSum_fintype _).summable, ?_⟩
  simp_rw [tsum_fintype, eulerChoice_sum_norm]
  exact summable_finsetProd_of_summable_nonneg (eulerChoiceNorm_nonneg w) hw

theorem eulerChoices_hasProd {κ : Type*} [DecidableEq κ] {A : κ → Type*} [∀ p, Fintype (A p)]
    (w : (p : κ) → A p → ℂ) (hw : Summable (eulerChoiceNorm w)) :
    HasProd (fun p => 1+∑ a, w p a) (∑' c : EulerChoices A, eulerChoiceTerm w c) := by
  classical
  have hs := (eulerChoice_summable_norm w hw).of_norm
  apply hasProd_one_add_of_hasSum_prod
  exact hs.hasSum.sigma fun P => by
    simpa only [eulerChoice_sum] using
      hasSum_fintype (fun c : (p : P) → A p => eulerChoiceTerm w ⟨P,c⟩)

end LargePrimeGaps

end OAI