import OAI.NumberTheory.GaussianMoat.BooleanCube

namespace OAI

universe uIota

namespace GaussianMoat
open MeasureTheory ProbabilityTheory
open scoped NNReal

def cubeEquiv : (n : ℕ) → Cube n ≃ (Fin n → Bool)
  | 0 => {
      toFun := fun _ i => Fin.elim0 i
      invFun := fun _ => ()
      left_inv := fun x => by cases x; rfl
      right_inv := fun f => by funext i; exact Fin.elim0 i }
  | n+1 => (Equiv.prodCongr (Equiv.refl Bool) (cubeEquiv n)).trans (Fin.consEquiv (fun _ => Bool))

noncomputable def cubeSignEquiv (ι : Type uIota) [Fintype ι] : Cube (Fintype.card ι) ≃ (ι → Bool) :=
  (cubeEquiv (Fintype.card ι)).trans
    (Equiv.arrowCongr (Fintype.equivFin ι).symm (Equiv.refl Bool))

noncomputable def signDist {ι : Type uIota} [Fintype ι] (σ τ : ι → Bool) : ℕ := by
  classical
  exact ∑ i, if σ i = τ i then 0 else 1

theorem cubeEquiv_dist (n : ℕ) (x y : Cube n) :
    signDist (cubeEquiv n x) (cubeEquiv n y) = cubeDist n x y := by
  classical
  induction n with
  | zero => simp [signDist, cubeDist]
  | succ n ih =>
    obtain ⟨b,x⟩ := x
    obtain ⟨c,y⟩ := y
    simp only [signDist, Fin.sum_univ_succ, cubeEquiv, Equiv.trans_apply,
      Equiv.prodCongr_apply, Fin.consEquiv_apply, Fin.cons_zero,
      Fin.cons_succ, cubeDist]
    congr 1
    exact ih x y

theorem cubeSignEquiv_dist (ι : Type uIota) [Fintype ι] (x y : Cube (Fintype.card ι)) :
    signDist (cubeSignEquiv ι x) (cubeSignEquiv ι y) = cubeDist (Fintype.card ι) x y := by
  classical
  rw [← cubeEquiv_dist]
  unfold signDist cubeSignEquiv
  simp only [Equiv.trans_apply, Equiv.arrowCongr_apply, Equiv.symm_symm]
  exact (Fintype.equivFin ι).sum_comp (fun i => if cubeEquiv (Fintype.card ι) x i =
    cubeEquiv (Fintype.card ι) y i then (0 : ℕ) else 1)

theorem signMeasure_real_singleton {ι : Type uIota} [Fintype ι] (σ : ι → Bool) :
    (signMeasure ι).real {σ} = ((2 : ℝ)^Fintype.card ι)⁻¹ := by
  simp [measureReal_def, signMeasure, Measure.pi_singleton, fairCoin,
    PMF.uniformOfFintype_apply]

open scoped Classical in

theorem signMeasure_real_set {ι : Type uIota} [Fintype ι] (S : Set (ι → Bool)) :
    (signMeasure ι).real S = (∑ σ, if σ ∈ S then (1 : ℝ) else 0) /
      (2 : ℝ)^Fintype.card ι := by
  classical
  have he : S = (↑(Finset.univ.filter (· ∈ S)) : Set (ι → Bool)) := by ext; simp
  conv_lhs => rw [he, ← sum_measureReal_singleton]
  rw [Finset.sum_filter, Finset.sum_div]
  apply Finset.sum_congr rfl
  intro σ _
  by_cases hσ : σ ∈ S <;> simp [hσ, signMeasure_real_singleton]

theorem cubeSignEquiv_measure {ι : Type uIota} [Fintype ι] (S : (ι → Bool) → Prop) :
    (signMeasure ι).real {σ | S σ} =
      (cubeSize (fun x => S (cubeSignEquiv ι x)) : ℝ) / (2 : ℝ)^Fintype.card ι := by
  classical
  rw [signMeasure_real_set]
  congr 1
  simp only [Set.mem_ofPred_eq]
  rw [← (cubeSignEquiv ι).sum_comp (fun σ => if S σ then (1 : ℝ) else 0)]
  simp only [cubeSize, Nat.cast_sum, Nat.cast_ite, Nat.cast_one, Nat.cast_zero]

noncomputable def SplitSieve.extendSigns (s : SplitSieve) (σ : s.primes → Bool) (p : ℕ) : Bool := by
  classical
  exact if hp : p ∈ s.primes then σ ⟨p,hp⟩ else false

@[simp] theorem SplitSieve.extendSigns_mem (s : SplitSieve) (σ : s.primes → Bool)
    (p : ℕ) (hp : p ∈ s.primes) : s.extendSigns σ p = σ ⟨p,hp⟩ := by
  simp [SplitSieve.extendSigns, hp]

noncomputable def SplitSieve.signedProduct (s : SplitSieve) (σ : s.primes → Bool) : GaussianInt :=
  ∏ p ∈ s.primes, signedFactor (s.factor p) (s.extendSigns σ p)

theorem SplitSieve.line_witness_log_lower (s : SplitSieve) (σ : s.primes → Bool)
    {v w : GaussianInt} (hv : PrimitiveDirection v) (hv0 : v ≠ 0) (hw : w ≠ 0)
    (hline : determinant v w = 0) (hdiv : s.signedProduct σ ∣ w)
    {B : ℝ} (hbound : (w.norm : ℝ) ≤ B) :
    Real.log (v.norm : ℝ) / 2 + (∑ p : s.primes, Real.log (p : ℝ)) - Real.log B / 2 ≤
      ∑ p : s.primes, s.lineLog v p (σ p) := by
  classical
  let t := s.primes.filter (fun p => ¬signedFactor (s.factor p) (s.extendSigns σ p) ∣ v)
  have hp (p : ℕ) (hp : p ∈ t) : 0 < (p : ℝ) := by
    exact_mod_cast (s.prime_mem p (Finset.mem_filter.mp hp).1).pos
  have hprod : 0 < ∏ p ∈ t, (p : ℝ) := Finset.prod_pos hp
  have hvpos : 0 < (v.norm : ℝ) := by exact_mod_cast (GaussianInt.norm_pos.mpr hv0)
  have hlo := s.line_witness_norm_lower s.primes (fun _ h => h) (s.extendSigns σ) hv hw hline hdiv
  have hlow : (v.norm : ℝ) * (∏ p ∈ t, (p : ℝ))^2 ≤ B := by
    apply le_trans ?_ hbound
    have hc : ((v.norm * (∏ p ∈ t, (p : ℤ))^2 : ℤ) : ℝ) ≤ (w.norm : ℝ) := by exact_mod_cast hlo
    push_cast at hc
    exact hc
  have hlog := Real.log_le_log (mul_pos hvpos (sq_pos_of_pos hprod)) hlow
  rw [Real.log_mul hvpos.ne' (sq_pos_of_pos hprod).ne', Real.log_pow,
    Real.log_prod (fun p hp' => (hp p hp').ne')] at hlog
  have hsum : (∑ p ∈ t, Real.log (p : ℝ)) =
      (∑ p : s.primes, Real.log (p : ℝ)) - ∑ p : s.primes, s.lineLog v p (σ p) := by
    calc
      _ = ∑ p ∈ s.primes, (Real.log (p : ℝ) - s.lineLog v p (s.extendSigns σ p)) := by
        unfold t
        rw [Finset.sum_filter]
        apply Finset.sum_congr rfl
        intro p hp'
        unfold SplitSieve.lineLog
        split_ifs <;> simp_all
      _ = _ := by
        rw [← Finset.sum_coe_sort s.primes
          (fun p => Real.log (p : ℝ) - s.lineLog v p (s.extendSigns σ p))]
        simp [SplitSieve.extendSigns, Finset.sum_sub_distrib]
  rw [hsum] at hlog
  norm_num only [Nat.cast_ofNat] at hlog
  linarith only [hlog]

def SplitSieve.lineEvent (s : SplitSieve) (Q : Set GaussianInt) (v : GaussianInt)
    (σ : s.primes → Bool) : Prop :=
  ∃ w ∈ Q, w ≠ 0 ∧ determinant v w = 0 ∧ s.signedProduct σ ∣ w

theorem SplitSieve.line_event_tail (s : SplitSieve) {Q : Set GaussianInt}
    {v : GaussianInt} (hv : PrimitiveDirection v) (hv0 : v ≠ 0) {B ε : ℝ}
    (hQ : ∀ w ∈ Q, (w.norm : ℝ) ≤ B) (hε : 0 ≤ ε)
    (hexcess : ε ≤ (∑ p : s.primes, Real.log (p : ℝ)) - Real.log B / 2) :
    (signMeasure s.primes).real {σ | s.lineEvent Q v σ} ≤
      Real.exp (-ε^2 / (2 * ∑ p : s.primes,
        (((‖Real.log (p : ℝ)‖₊ / 2)^2 : ℝ≥0) : ℝ))) := by
  apply le_trans (measureReal_mono (s₂ := {σ |
    Real.log (v.norm : ℝ) / 2 + ε ≤ ∑ p : s.primes, s.lineLog v p (σ p)}) ?_)
  · exact s.lineLog_tail hv hv0 hε
  · rintro σ ⟨w,hwQ,hw,hline,hd⟩
    have hl := s.line_witness_log_lower σ hv hv0 hw hline hd (hQ w hwQ)
    change Real.log (v.norm : ℝ) / 2 + ε ≤ _
    linarith

open scoped Classical in

noncomputable def SplitSieve.commonProduct (s : SplitSieve) (σ τ : s.primes → Bool) : GaussianInt :=
  ∏ p ∈ s.primes.filter (fun p => s.extendSigns σ p = s.extendSigns τ p),
    signedFactor (s.factor p) (s.extendSigns σ p)

theorem SplitSieve.commonProduct_dvd_left (s : SplitSieve) (σ τ : s.primes → Bool) :
    s.commonProduct σ τ ∣ s.signedProduct σ := by
  classical
  exact Finset.prod_dvd_prod_of_subset _ _ _ (Finset.filter_subset _ _)

theorem SplitSieve.commonProduct_comm (s : SplitSieve) (σ τ : s.primes → Bool) :
    s.commonProduct σ τ = s.commonProduct τ σ := by
  classical
  unfold SplitSieve.commonProduct
  apply Finset.prod_congr
  · ext p
    simp only [Finset.mem_filter, eq_comm]
  · intro p hp
    rw [(Finset.mem_filter.mp hp).2]

theorem SplitSieve.commonProduct_dvd_right (s : SplitSieve) (σ τ : s.primes → Bool) :
    s.commonProduct σ τ ∣ s.signedProduct τ := by
  rw [s.commonProduct_comm]
  exact s.commonProduct_dvd_left τ σ

open scoped Classical in
theorem SplitSieve.signDist_eq_card (s : SplitSieve) (σ τ : s.primes → Bool) :
    signDist σ τ = (s.primes.filter (fun p => s.extendSigns σ p ≠ s.extendSigns τ p)).card := by
  classical
  rw [Finset.card_eq_sum_ones, Finset.sum_filter, ← Finset.sum_coe_sort s.primes
    (fun p => if s.extendSigns σ p ≠ s.extendSigns τ p then 1 else 0)]
  unfold signDist
  apply Finset.sum_congr rfl
  intro p _
  simp [SplitSieve.extendSigns]

theorem SplitSieve.period_le_common_norm (s : SplitSieve) (σ τ : s.primes → Bool)
    {U : ℝ} (hpU : ∀ p ∈ s.primes, (p : ℝ) ≤ U) :
    (s.period : ℝ) ≤ ((s.commonProduct σ τ).norm : ℝ) * U^(signDist σ τ) := by
  classical
  let c := s.primes.filter (fun p => s.extendSigns σ p = s.extendSigns τ p)
  let d := s.primes.filter (fun p => s.extendSigns σ p ≠ s.extendSigns τ p)
  have hc : ((s.commonProduct σ τ).norm : ℝ) = ∏ p ∈ c, (p : ℝ) := by
    unfold SplitSieve.commonProduct
    rw [norm_finset_prod, Int.cast_prod]
    apply Finset.prod_congr rfl
    intro p hp
    rw [signedFactor_norm, s.factor_norm p (Finset.mem_filter.mp hp).1]
    exact_mod_cast (rfl : (p : ℝ) = p)
  have hd : (∏ p ∈ d, (p : ℝ)) ≤ U^d.card := by
    rw [← Finset.prod_const]
    exact Finset.prod_le_prod₀ (fun p _ => Nat.cast_nonneg p)
      (fun p hp => hpU p (Finset.mem_filter.mp hp).1)
  have hp : (s.period : ℝ) = (∏ p ∈ c, (p : ℝ)) * (∏ p ∈ d, (p : ℝ)) := by
    unfold SplitSieve.period
    push_cast
    exact (Finset.prod_filter_mul_prod_filter_not s.primes
      (fun p => s.extendSigns σ p = s.extendSigns τ p) (fun p => (p : ℝ))).symm
  rw [hp, hc, s.signDist_eq_card]
  exact mul_le_mul_of_nonneg_left hd (Finset.prod_nonneg (fun p _ => Nat.cast_nonneg p))

theorem SplitSieve.near_witnesses_collinear (s : SplitSieve) (σ τ : s.primes → Bool)
    {w w' : GaussianInt} (hw : s.signedProduct σ ∣ w) (hw' : s.signedProduct τ ∣ w')
    {U B : ℝ} (hU : 0 < U) (hpU : ∀ p ∈ s.primes, (p : ℝ) ≤ U)
    (hdet : (|determinant w w'| : ℝ) ≤ B)
    (hsmall : B * U^(signDist σ τ) < (s.period : ℝ)) : determinant w w' = 0 := by
  have hbound := lt_of_lt_of_le hsmall (s.period_le_common_norm σ τ hpU)
  have hlt : B < ((s.commonProduct σ τ).norm : ℝ) :=
    (mul_lt_mul_iff_left₀ (pow_pos hU _)).mp (by simpa only [mul_comm] using hbound)
  apply determinant_eq_zero_of_common_factor
    ((s.commonProduct_dvd_left σ τ).trans hw) ((s.commonProduct_dvd_right σ τ).trans hw')
  exact_mod_cast hdet.trans_lt hlt

theorem determinant_zero_trans {u v w : GaussianInt} (hv : v ≠ 0)
    (huv : determinant u v = 0) (hvw : determinant v w = 0) :
    determinant u w = 0 := by
  have hcoord : v.re ≠ 0 ∨ v.im ≠ 0 := by
    contrapose! hv
    ext <;> simp [hv.1, hv.2]
  unfold determinant at *
  rcases hcoord with hr | hi
  · apply (mul_eq_zero.mp (show v.re * (u.re * w.im - u.im * w.re) = 0 by
      nlinarith [congrArg (fun x : ℤ => x * w.re) huv,
        congrArg (fun x : ℤ => u.re * x) hvw])).resolve_left hr
  · apply (mul_eq_zero.mp (show v.im * (u.re * w.im - u.im * w.re) = 0 by
      nlinarith [congrArg (fun x : ℤ => x * w.im) huv,
        congrArg (fun x : ℤ => u.im * x) hvw])).resolve_left hi

@[simp] theorem determinant_self (v : GaussianInt) : determinant v v = 0 := by
  unfold determinant
  ring

theorem determinant_swap (u v : GaussianInt) : determinant u v = -determinant v u := by
  unfold determinant
  ring

def witnessLine (v : GaussianInt) : Set GaussianInt := {w | determinant v w = 0}

theorem witnessLine_eq {v w : GaussianInt} (hv : v ≠ 0) (hw : w ≠ 0)
    (hvw : determinant v w = 0) : witnessLine v = witnessLine w := by
  ext u
  constructor
  · intro hu
    exact determinant_zero_trans hv (by rw [determinant_swap, hvw, neg_zero]) hu
  · exact determinant_zero_trans hw hvw

def SplitSieve.badSign (s : SplitSieve) (Q : Set GaussianInt) (σ : s.primes → Bool) : Prop :=
  ∃ w ∈ Q, w ≠ 0 ∧ s.signedProduct σ ∣ w

noncomputable def SplitSieve.badWitness (s : SplitSieve) (Q : Set GaussianInt)
    (σ : {σ : s.primes → Bool // s.badSign Q σ}) : GaussianInt := σ.property.choose

theorem SplitSieve.badWitness_spec (s : SplitSieve) (Q : Set GaussianInt)
    (σ : {σ : s.primes → Bool // s.badSign Q σ}) :
    s.badWitness Q σ ∈ Q ∧ s.badWitness Q σ ≠ 0 ∧ s.signedProduct σ.val ∣ s.badWitness Q σ :=
  σ.property.choose_spec

def SplitSieve.badLines (s : SplitSieve) (Q : Set GaussianInt) : Set (Set GaussianInt) :=
  Set.range (fun σ : {σ : s.primes → Bool // s.badSign Q σ} => witnessLine (s.badWitness Q σ))

instance SplitSieve.badLines_finite (s : SplitSieve) (Q : Set GaussianInt) :
    Finite (s.badLines Q) := by
  unfold SplitSieve.badLines
  infer_instance

theorem SplitSieve.badLine_primitive (s : SplitSieve) (Q : Set GaussianInt)
    (L : s.badLines Q) : ∃ v : GaussianInt, PrimitiveDirection v ∧ v ≠ 0 ∧ witnessLine v = L.val := by
  obtain ⟨σ, hσ⟩ := L.property
  have hw := s.badWitness_spec Q σ
  obtain ⟨v,hv,hv0,a,_hanz,ha⟩ := exists_primitive_direction hw.2.1
  refine ⟨v,hv,hv0, ?_⟩
  rw [← hσ]
  apply witnessLine_eq hv0 hw.2.1
  rw [ha]
  unfold determinant
  simp only [Zsqrtd.re_mul, Zsqrtd.im_mul, Zsqrtd.re_intCast, Zsqrtd.im_intCast]
  ring

def SplitSieve.lineClass (s : SplitSieve) (Q : Set GaussianInt) (L : s.badLines Q)
    (σ : s.primes → Bool) : Prop :=
  ∃ hσ : s.badSign Q σ, witnessLine (s.badWitness Q ⟨σ,hσ⟩) = L.val

theorem SplitSieve.badSign_iff_class (s : SplitSieve) (Q : Set GaussianInt) (σ : s.primes → Bool) :
    s.badSign Q σ ↔ ∃ L : s.badLines Q, s.lineClass Q L σ := by
  constructor
  · intro hσ
    exact ⟨⟨witnessLine (s.badWitness Q ⟨σ,hσ⟩), ⟨⟨σ,hσ⟩,rfl⟩⟩, hσ, rfl⟩
  · rintro ⟨L,hσ,_⟩
    exact hσ

theorem SplitSieve.lineClass_subset_event (s : SplitSieve) (Q : Set GaussianInt)
    (L : s.badLines Q) {v : GaussianInt} (hvL : witnessLine v = L.val) :
    {σ | s.lineClass Q L σ} ⊆ {σ | s.lineEvent Q v σ} := by
  rintro σ ⟨hσ,hL⟩
  have hw := s.badWitness_spec Q ⟨σ,hσ⟩
  refine ⟨_,hw.1,hw.2.1,?_,hw.2.2⟩
  change s.badWitness Q ⟨σ,hσ⟩ ∈ witnessLine v
  rw [hvL, ← hL]
  exact determinant_self _

theorem SplitSieve.lineClasses_separated (s : SplitSieve) (Q : Set GaussianInt)
    {U B : ℝ} (hU : 1 ≤ U) (hpU : ∀ p ∈ s.primes, (p : ℝ) ≤ U)
    (hdet : ∀ w ∈ Q, ∀ w' ∈ Q, (|determinant w w'| : ℝ) ≤ B)
    {h : ℕ} (hsmall : B * U^(2*h) < (s.period : ℝ)) (hB : 0 ≤ B) :
    ∀ L L' : s.badLines Q, L ≠ L' → ∀ σ, s.lineClass Q L σ →
      ∀ τ, s.lineClass Q L' τ → 2*h < signDist σ τ := by
  intro L L' hLL σ ⟨hσ,hσL⟩ τ ⟨hτ,hτL⟩
  by_contra hn
  have hd : signDist σ τ ≤ 2*h := le_of_not_gt hn
  have hw := s.badWitness_spec Q ⟨σ,hσ⟩
  have hw' := s.badWitness_spec Q ⟨τ,hτ⟩
  have hsm : B * U^(signDist σ τ) < (s.period : ℝ) :=
    (mul_le_mul_of_nonneg_left (pow_le_pow_right₀ hU hd) hB).trans_lt hsmall
  have hcol := s.near_witnesses_collinear σ τ hw.2.2 hw'.2.2 (by linarith) hpU
    (hdet _ hw.1 _ hw'.1) hsm
  apply hLL
  apply Subtype.ext
  rw [← hσL, ← hτL]
  exact witnessLine_eq hw.2.1 hw'.2.1 hcol

theorem cubeSize_exists_le_sum {n : ℕ} {ι : Type uIota} [Fintype ι]
    (S : ι → Cube n → Prop) : cubeSize (fun x => ∃ i, S i x) ≤ ∑ i, cubeSize (S i) := by
  classical
  unfold cubeSize
  rw [Finset.sum_comm]
  apply Finset.sum_le_sum
  intro x _
  by_cases hx : ∃ i, S i x
  · obtain ⟨i, hi⟩ := hx
    rw [ite_eq_left ⟨i,hi⟩]
    have h : (if S i x then 1 else 0) ≤ ∑ j : ι, if S j x then 1 else 0 :=
      Finset.single_le_sum (f := fun j => if S j x then (1 : ℕ) else 0)
        (fun _ _ => Nat.zero_le _) (Finset.mem_univ i)
    simpa only [ite_eq_left hi] using h
  · simp only [ite_eq_right hx]
    exact Nat.zero_le _

theorem SplitSieve.signed_region_bound (s : SplitSieve) (Q : Set GaussianInt)
    (hr : 0 < s.primes.card) {U B N ε a E A : ℝ} {h : ℕ}
    (hU : 1 ≤ U) (hpU : ∀ p ∈ s.primes, (p : ℝ) ≤ U)
    (hB : 0 ≤ B) (hdet : ∀ w ∈ Q, ∀ w' ∈ Q, (|determinant w w'| : ℝ) ≤ B)
    (hsmall : B * U^(2*h) < (s.period : ℝ))
    (hQ : ∀ w ∈ Q, (w.norm : ℝ) ≤ N) (hε : 0 ≤ ε)
    (hexcess : ε ≤ (∑ p : s.primes, Real.log (p : ℝ)) - Real.log N / 2)
    (ha : 0 ≤ a) (hE : 0 < E) (hA : 0 < A)
    (hlogE : Real.log E ≤ (s.primes.card : ℝ) * Real.log 2 - a)
    (hseed : A * Real.exp (-ε^2 / (2 * ∑ p : s.primes,
      (((‖Real.log (p : ℝ)‖₊ / 2)^2 : ℝ≥0) : ℝ))) * (2 : ℝ)^s.primes.card ≤ E)
    (hfactor : A ≤ (1 + a / ((s.primes.card : ℝ)*Real.log 2))^h) :
    (signMeasure s.primes).real {σ | s.badSign Q σ} ≤ A⁻¹ := by
  classical
  let : Fintype (s.badLines Q) := Fintype.ofFinite _
  let S : s.badLines Q → Cube (Fintype.card s.primes) → Prop :=
    fun L x => s.lineClass Q L (cubeSignEquiv s.primes x)
  have hcard : Fintype.card s.primes = s.primes.card := Fintype.card_coe _
  have hpow : 0 < (2 : ℝ)^Fintype.card s.primes := pow_pos (by norm_num) _
  have hseed' (L : s.badLines Q) : A * cubeSize (S L) ≤ E := by
    obtain ⟨v,hv,hv0,hvL⟩ := s.badLine_primitive Q L
    have hm := (measureReal_mono (s.lineClass_subset_event Q L hvL)).trans
      (s.line_event_tail hv hv0 hQ hε hexcess)
    rw [cubeSignEquiv_measure] at hm
    have hc : (cubeSize (S L) : ℝ) ≤ Real.exp (-ε^2 / (2 * ∑ p : s.primes,
        (((‖Real.log (p : ℝ)‖₊ / 2)^2 : ℝ≥0) : ℝ))) * (2 : ℝ)^Fintype.card s.primes :=
      (div_le_iff₀ hpow).mp hm
    have hh := mul_le_mul_of_nonneg_left hc hA.le
    exact hh.trans (by simpa only [hcard, mul_assoc] using hseed)
  have hsep : ∀ L L' : s.badLines Q, L ≠ L' → ∀ x, S L x → ∀ y, S L' y →
      2*h < cubeDist (Fintype.card s.primes) x y := by
    intro L L' hLL x hx y hy
    have hh := s.lineClasses_separated Q hU hpU hdet hsmall hB L L' hLL
      (cubeSignEquiv s.primes x) hx (cubeSignEquiv s.primes y) hy
    simpa only [cubeSignEquiv_dist] using hh
  have hpack := cube_separated_bound (n := Fintype.card s.primes) (h := h)
    (by simpa only [hcard] using hr) S ha hE (by simpa only [hcard] using hlogE)
    hseed' (by simpa only [hcard] using hfactor) hsep
  have hunion : (cubeSize (fun x => s.badSign Q (cubeSignEquiv s.primes x)) : ℝ) ≤
      ∑ L, (cubeSize (S L) : ℝ) := by
    have he : (fun x => s.badSign Q (cubeSignEquiv s.primes x)) = (fun x => ∃ L, S L x) := by
      funext x
      exact propext (s.badSign_iff_class Q _)
    rw [he]
    exact_mod_cast cubeSize_exists_le_sum S
  rw [cubeSignEquiv_measure, div_le_iff₀ hpow]
  have hh := (mul_le_mul_of_nonneg_left hunion hA.le).trans hpack
  calc
    _ ≤ (2 : ℝ)^Fintype.card s.primes / A := (le_div_iff₀ hA).mpr (by simpa only [mul_comm] using hh)
    _ = _ := by rw [div_eq_mul_inv, mul_comm]

theorem SplitSieve.signed_region_exp_bound (s : SplitSieve) (Q : Set GaussianInt)
    (hr : 0 < s.primes.card) {U B N ε a b : ℝ} {h : ℕ}
    (hU : 1 ≤ U) (hpU : ∀ p ∈ s.primes, (p : ℝ) ≤ U)
    (hB : 0 ≤ B) (hdet : ∀ w ∈ Q, ∀ w' ∈ Q, (|determinant w w'| : ℝ) ≤ B)
    (hsmall : B * U^(2*h) < (s.period : ℝ))
    (hQ : ∀ w ∈ Q, (w.norm : ℝ) ≤ N) (hε : 0 ≤ ε)
    (hexcess : ε ≤ (∑ p : s.primes, Real.log (p : ℝ)) - Real.log N / 2)
    (ha : 0 ≤ a) (hb : b ≤ a)
    (htail : 2*a ≤ ε^2 / (2 * ∑ p : s.primes,
      (((‖Real.log (p : ℝ)‖₊ / 2)^2 : ℝ≥0) : ℝ)))
    (hgrowth : b ≤ (h : ℝ) * Real.log (1 + a / ((s.primes.card : ℝ)*Real.log 2))) :
    (signMeasure s.primes).real {σ | s.badSign Q σ} ≤ Real.exp (-b) := by
  have htwo : 0 < Real.log 2 := Real.log_pos (by norm_num)
  have hr' : 0 < (s.primes.card : ℝ) := by exact_mod_cast hr
  have hbase : 0 < 1 + a / ((s.primes.card : ℝ)*Real.log 2) := by
    have := div_nonneg ha (mul_pos hr' htwo).le
    linarith
  have hbexp : Real.exp b ≤ (1 + a / ((s.primes.card : ℝ)*Real.log 2))^h := by
    rw [← Real.exp_log (pow_pos hbase h)]
    apply Real.exp_le_exp.mpr
    simpa only [Real.log_pow] using hgrowth
  have hh := s.signed_region_bound Q hr hU hpU hB hdet hsmall hQ hε hexcess ha
    (E := (2 : ℝ)^s.primes.card * Real.exp (-a))
    (A := Real.exp b) (h := h) (mul_pos (pow_pos (by norm_num) _) (Real.exp_pos _))
    (Real.exp_pos _) (by
      rw [Real.log_mul (pow_pos (by norm_num : (0 : ℝ) < 2) _).ne' (Real.exp_pos _).ne',
        Real.log_pow, Real.log_exp]
      linarith) (by
      rw [← Real.exp_add]
      have he : b + -ε^2 / (2 * ∑ p : s.primes,
          (((‖Real.log (p : ℝ)‖₊ / 2)^2 : ℝ≥0) : ℝ)) ≤ -a := by
        rw [neg_div]
        linarith
      exact (mul_le_mul_of_nonneg_right (Real.exp_le_exp.mpr he)
        (pow_nonneg (by norm_num) _)).trans_eq (mul_comm _ _)) hbexp
  simpa only [Real.exp_neg] using hh

def orientedRectangle (e : ℂ) (R W : ℝ) : Set GaussianInt :=
  {z | |(star e * (z : ℂ)).re| ≤ R ∧ |(star e * (z : ℂ)).im| ≤ W}

theorem rectangle_norm_bound {e : ℂ} (he : ‖e‖ = 1) {R W : ℝ}
    (hW : 0 ≤ W) (hWR : W ≤ R) {z : GaussianInt} (hz : z ∈ orientedRectangle e R W) :
    (z.norm : ℝ) ≤ 2 * R^2 := by
  have hnorm : ‖star e * (z : ℂ)‖ = ‖(z : ℂ)‖ := by
    rw [norm_mul, norm_star, he, one_mul]
  rw [norm_square_complex, ← hnorm, ← Complex.normSq_eq_norm_sq, Complex.normSq_apply]
  have hx : (star e * (z : ℂ)).re ^ 2 ≤ R^2 := by
    simpa only [sq_abs] using (sq_le_sq₀ (abs_nonneg ((star e * (z : ℂ)).re))
      (hW.trans hWR)).mpr hz.1
  have hy : (star e * (z : ℂ)).im ^ 2 ≤ W^2 := by
    simpa only [sq_abs] using (sq_le_sq₀ (abs_nonneg ((star e * (z : ℂ)).im)) hW).mpr hz.2
  have hww := (sq_le_sq₀ hW (hW.trans hWR)).mpr hWR
  nlinarith

theorem determinant_rotated (e : ℂ) (he : ‖e‖ = 1) (z w : GaussianInt) :
    (determinant z w : ℝ) =
      (star e * (z : ℂ)).re * (star e * (w : ℂ)).im -
      (star e * (z : ℂ)).im * (star e * (w : ℂ)).re := by
  have hsq : e.re^2 + e.im^2 = 1 := by
    have hh := Complex.normSq_eq_norm_sq e
    rw [he] at hh
    simpa [Complex.normSq_apply, pow_two] using hh
  simp only [Complex.mul_re, Complex.mul_im, Complex.star_def, Complex.conj_re, Complex.conj_im,
    ← GaussianInt.intCast_re, ← GaussianInt.intCast_im, determinant, Int.cast_sub, Int.cast_mul]
  nlinarith [congrArg (fun x : ℝ => x * ((z.re : ℝ) * w.im - z.im * w.re)) hsq]

theorem rectangle_determinant_bound {e : ℂ} (he : ‖e‖ = 1) {R W : ℝ}
    (hR : 0 ≤ R) (hW : 0 ≤ W) {z w : GaussianInt}
    (hz : z ∈ orientedRectangle e R W) (hw : w ∈ orientedRectangle e R W) :
    (|determinant z w| : ℝ) ≤ 2*R*W := by
  rw [determinant_rotated e he]
  apply (abs_sub _ _).trans
  rw [abs_mul, abs_mul]
  have h1 := mul_le_mul hz.1 hw.2 (abs_nonneg _) hR
  have h2 := mul_le_mul hz.2 hw.1 (abs_nonneg _) hW
  nlinarith

theorem rectangle_cube_growth {r : ℕ} {d : ℝ} (hd : 0 < d) (hd1 : d ≤ 1/4)
    (hlarge : 1000 ≤ d^3 * r) :
    let h := ⌊d * r / 10⌋₊
    d^3 * r / 5120 ≤ (h : ℝ) * Real.log (1 + (d^2 * r / 64) / ((r : ℝ) * Real.log 2)) := by
  dsimp only
  have hr : 0 < (r : ℝ) := by
    by_contra h
    have hr0 : (r : ℝ) = 0 := le_antisymm (le_of_not_gt h) (Nat.cast_nonneg _)
    rw [hr0, mul_zero] at hlarge
    norm_num at hlarge
  have loglo : (1/2 : ℝ) ≤ Real.log 2 := by linarith [Real.log_two_gt_d9]
  have loghi : Real.log 2 ≤ 1 := by linarith [Real.log_two_lt_d9]
  have hlog : 0 < Real.log 2 := lt_of_lt_of_le (by norm_num) loglo
  have hdle : d ≤ 1 := by linarith
  have hsq : d^2 ≤ 1 := by nlinarith
  have hdr : d^3 * r ≤ d * r := by
    exact mul_le_mul_of_nonneg_right (by nlinarith [mul_nonneg hd.le (sub_nonneg.mpr hsq)]) hr.le
  have hfloor : d * r / 20 ≤ (⌊d * r / 10⌋₊ : ℝ) := by
    have hh := Nat.lt_floor_add_one (d * r / 10)
    have hdrl : 1000 ≤ d * r := hlarge.trans hdr
    linarith
  have heq : (d^2 * r / 64) / ((r : ℝ) * Real.log 2) = d^2 / (64 * Real.log 2) := by
    field_simp
  let δ := d^2 / (64 * Real.log 2)
  have hδ : 0 ≤ δ := div_nonneg (sq_nonneg _) (by positivity)
  have hδ1 : δ ≤ 1 := by
    apply (div_le_iff₀ (mul_pos (by norm_num) hlog)).mpr
    nlinarith
  have hδlo : d^2 / 64 ≤ δ := by
    apply (le_div_iff₀ (mul_pos (by norm_num) hlog)).mpr
    nlinarith [mul_nonneg (sq_nonneg d) (sub_nonneg.mpr loghi)]
  have hlogδ : δ/2 ≤ Real.log (1+δ) := by
    apply le_trans ?_ (Real.le_log_one_add_of_nonneg hδ)
    apply (le_div_iff₀ (by linarith : 0 < δ+2)).mpr
    nlinarith [mul_nonneg hδ (sub_nonneg.mpr hδ1)]
  rw [heq]
  change _ ≤ (⌊d * r / 10⌋₊ : ℝ) * Real.log (1+δ)
  have hm := mul_le_mul hfloor hlogδ (by linarith) (Nat.cast_nonneg _)
  have hm' : d^3 * r / 2560 ≤ (d*r/20) * (δ/2) := by
    have := mul_le_mul_of_nonneg_left hδlo (by positivity : 0 ≤ d*r/40)
    nlinarith
  have hnon : 0 ≤ d^3 * r := by positivity
  nlinarith

theorem rectangle_linear_large {r d : ℝ} (hr : 0 ≤ r) (hd : 0 ≤ d) (hd1 : d ≤ 1)
    (hlarge : 1000 ≤ d^3 * r) : 1000 ≤ d*r := by
  have hs : d^2 ≤ 1 := by nlinarith
  have hc : d^3 ≤ d := by nlinarith [mul_nonneg hd (sub_nonneg.mpr hs)]
  exact hlarge.trans (mul_le_mul_of_nonneg_right hc hr)

theorem rectangle_log_small {r : ℕ} {d t u l : ℝ}
    (hd : 0 < d) (hd1 : d ≤ 1/4) (ht : 1/2 ≤ t) (hu : 0 ≤ u) (hutu : u ≤ 2*t)
    (hl : (r : ℝ)*t ≤ l) (hlarge : 1000 ≤ d^3 * r) :
    Real.log 2 + (1-d)*l + (2*⌊d*r/10⌋₊ : ℕ)*u < l := by
  have hdr : 1000 ≤ d*r := rectangle_linear_large (Nat.cast_nonneg _) hd.le (by linarith) hlarge
  have hf : (⌊d*r/10⌋₊ : ℝ) ≤ d*r/10 := Nat.floor_le (by positivity)
  have hm : (2*⌊d*r/10⌋₊ : ℕ)*u ≤ (d*r/5)*(2*t) := by
    push_cast
    apply mul_le_mul (by linarith) hutu hu
    positivity
  have hdl := mul_le_mul_of_nonneg_left hl hd.le
  have hdt : 500 ≤ d*r*t := by
    have hh := mul_le_mul_of_nonneg_left ht (by positivity : 0 ≤ d*r)
    nlinarith
  have hlog : Real.log 2 ≤ 1 := by linarith [Real.log_two_lt_d9]
  nlinarith

theorem rectangle_log_excess {r : ℕ} {d t l : ℝ} (hd : 0 < d) (hd1 : d ≤ 1/4)
    (ht : 1/2 ≤ t) (hl : (r : ℝ)*t ≤ l) (hlarge : 1000 ≤ d^3 * r) :
    d*l/2 ≤ l - ((1-d)*l + Real.log 2/2) := by
  have hdr : 1000 ≤ d*r := rectangle_linear_large (Nat.cast_nonneg _) hd.le (by linarith) hlarge
  have h1 := mul_le_mul_of_nonneg_left hl hd.le
  have h2 := mul_le_mul_of_nonneg_left ht (by positivity : 0 ≤ d*r)
  have hlog : Real.log 2 ≤ 1 := by linarith [Real.log_two_lt_d9]
  nlinarith

theorem rectangle_hoeffding_exponent {r d t l V : ℝ} (hr : 0 < r) (hd : 0 ≤ d)
    (ht : 0 < t) (hl : r*t ≤ l) (hV : 0 < V) (hVup : V ≤ r*t^2) :
    2*(d^2*r/64) ≤ (d*l/2)^2 / (2*V) := by
  have hdl : 0 ≤ d*r*t/2 := by positivity
  have hdl' : d*r*t/2 ≤ d*l/2 := by nlinarith [mul_le_mul_of_nonneg_left hl hd]
  have hs : (d*r*t/2)^2 ≤ (d*l/2)^2 := (sq_le_sq₀ hdl (hdl.trans hdl')).mpr hdl'
  have hden : 0 < 2*r*t^2 := by positivity
  calc
    2*(d^2*r/64) ≤ d^2*r/8 := by nlinarith [mul_nonneg (sq_nonneg d) hr.le]
    _ = (d*r*t/2)^2 / (2*r*t^2) := by field_simp; ring
    _ ≤ (d*l/2)^2 / (2*r*t^2) := div_le_div_of_nonneg_right hs hden.le
    _ ≤ (d*l/2)^2 / (2*V) := div_le_div_of_nonneg_left (sq_nonneg _) (by positivity) (by nlinarith)

theorem SplitSieve.log_period (s : SplitSieve) :
    Real.log (s.period : ℝ) = ∑ p : s.primes, Real.log (p : ℝ) := by
  classical
  unfold SplitSieve.period
  push_cast
  rw [Real.log_prod (fun p hp => by
    exact_mod_cast (s.prime_mem p hp).ne_zero)]
  exact (Finset.sum_coe_sort s.primes (fun p => Real.log (p : ℝ))).symm

noncomputable def SplitSieve.logVariance (s : SplitSieve) : ℝ :=
  ∑ p : s.primes, (((‖Real.log (p : ℝ)‖₊ / 2)^2 : ℝ≥0) : ℝ)

theorem SplitSieve.logVariance_pos (s : SplitSieve) (hr : 0 < s.primes.card) :
    0 < s.logVariance := by
  classical
  obtain ⟨p,hp⟩ := Finset.card_pos.mp hr
  have hlog : 0 < Real.log (p : ℝ) := Real.log_pos (by exact_mod_cast (s.prime_mem p hp).one_lt)
  apply Finset.sum_pos' (fun _ _ => by positivity)
  refine ⟨⟨p,hp⟩, Finset.mem_univ _, ?_⟩
  simp only [NNReal.coe_pow, NNReal.coe_div, NNReal.coe_ofNat, coe_nnnorm, Real.norm_eq_abs,
    abs_of_pos hlog]
  positivity

theorem SplitSieve.logVariance_le (s : SplitSieve) {U : ℝ}
    (hU : 1 ≤ U) (hpU : ∀ p ∈ s.primes, (p : ℝ) ≤ U) :
    s.logVariance ≤ (s.primes.card : ℝ) * (Real.log U / 2)^2 := by
  classical
  calc
    _ ≤ ∑ _p : s.primes, (Real.log U / 2)^2 := by
      apply Finset.sum_le_sum
      intro p _
      have hp : 0 < (p : ℝ) := by exact_mod_cast (s.prime_mem p p.property).pos
      have hlog : 0 ≤ Real.log (p : ℝ) := Real.log_nonneg (by exact_mod_cast (s.prime_mem p p.property).one_le)
      have hle := Real.log_le_log hp (hpU p p.property)
      simp only [NNReal.coe_pow, NNReal.coe_div, NNReal.coe_ofNat, coe_nnnorm, Real.norm_eq_abs,
        abs_of_nonneg hlog]
      exact (sq_le_sq₀ (by positivity) (div_nonneg (Real.log_nonneg hU) (by norm_num))).mpr (by linarith)
    _ = _ := by simp [nsmul_eq_mul]

theorem SplitSieve.signed_rectangle (s : SplitSieve)
    {T R W d : ℝ} {e : ℂ} (he : ‖e‖ = 1) (hT : 5 ≤ T)
    (hpT : ∀ p ∈ s.primes, T ≤ (p : ℝ) ∧ (p : ℝ) ≤ 2*T)
    (hW : 1 ≤ W) (hWR : W ≤ R) (hd : 0 < d) (hd1 : d < 1/4)
    (harea : R*W ≤ (s.period : ℝ)^(1-d)) (hlarge : 1000 ≤ d^3*s.primes.card) :
    (signMeasure s.primes).real {σ | s.badSign (orientedRectangle e R W) σ} ≤
      Real.exp (-(d^3*s.primes.card/5120)) := by
  have hr : 0 < s.primes.card := by
    by_contra h
    have hz : s.primes.card = 0 := Nat.eq_zero_of_not_pos h
    rw [hz, Nat.cast_zero, mul_zero] at hlarge
    norm_num at hlarge
  have hr' : 0 < (s.primes.card : ℝ) := by exact_mod_cast hr
  have hP : 0 < (s.period : ℝ) := by exact_mod_cast s.period_pos
  have hTpos : 0 < T := by linarith
  have hU : 1 ≤ 2*T := by linarith
  have hUpos : 0 < 2*T := by linarith
  have hWpos : 0 < W := by linarith
  have hRpos : 0 < R := lt_of_lt_of_le hWpos hWR
  have hRW : 0 < R*W := mul_pos hRpos hWpos
  have hlogT : 1/2 ≤ Real.log T := by
    have hlog2T := Real.log_le_log (by norm_num : (0 : ℝ) < 2) (by linarith : 2 ≤ T)
    linarith [Real.log_two_gt_d9]
  have hlogU : Real.log (2*T) ≤ 2*Real.log T := by
    rw [Real.log_mul (by norm_num) hTpos.ne']
    have hh := Real.log_le_log (by norm_num : (0 : ℝ) < 2) (by linarith : 2 ≤ T)
    linarith
  have hlogP : (s.primes.card : ℝ)*Real.log T ≤ Real.log (s.period : ℝ) := by
    rw [s.log_period]
    calc
      _ = ∑ _p : s.primes, Real.log T := by simp [nsmul_eq_mul]
      _ ≤ _ := Finset.sum_le_sum (fun p _ => Real.log_le_log hTpos (hpT p p.property).1)
  have hlogPpos : 0 < Real.log (s.period : ℝ) :=
    (mul_pos hr' (by linarith : 0 < Real.log T)).trans_le hlogP
  have hRarea : R ≤ R*W := by nlinarith
  have hlogR : Real.log R ≤ (1-d)*Real.log (s.period : ℝ) := by
    have hh := Real.log_le_log hRpos (hRarea.trans harea)
    simpa only [Real.log_rpow hP] using hh
  have hlogB : Real.log (2*R*W) ≤ Real.log 2 + (1-d)*Real.log (s.period : ℝ) := by
    have hh := Real.log_le_log hRW harea
    rw [Real.log_rpow hP] at hh
    have heq : 2*R*W = 2*(R*W) := by ring
    rw [heq, Real.log_mul (by norm_num) hRW.ne']
    linarith
  have hlogN : Real.log (2*R^2)/2 ≤ (1-d)*Real.log (s.period : ℝ) + Real.log 2/2 := by
    rw [Real.log_mul (by norm_num) (pow_pos hRpos 2).ne', Real.log_pow]
    norm_num only [Nat.cast_ofNat]
    linarith
  let h : ℕ := ⌊d*s.primes.card/10⌋₊
  have hsmall : (2*R*W) * (2*T)^(2*h) < (s.period : ℝ) := by
    apply (Real.log_lt_log_iff (mul_pos (by positivity) (pow_pos hUpos _)) hP).mp
    rw [Real.log_mul (by positivity : 2*R*W ≠ 0) (pow_pos hUpos _).ne', Real.log_pow]
    have hh := rectangle_log_small hd hd1.le hlogT (Real.log_nonneg hU) hlogU hlogP hlarge
    exact (add_le_add_left hlogB _).trans_lt hh
  have hV := s.logVariance_pos hr
  have hVup : s.logVariance ≤ (s.primes.card : ℝ)*(Real.log T)^2 := by
    apply (s.logVariance_le hU (fun p hp => (hpT p hp).2)).trans
    apply mul_le_mul_of_nonneg_left ?_ hr'.le
    apply (sq_le_sq₀ (div_nonneg (Real.log_nonneg hU) (by norm_num)) (by linarith : 0 ≤ Real.log T)).mpr
    linarith
  apply s.signed_region_exp_bound (orientedRectangle e R W) hr hU
    (fun p hp => (hpT p hp).2) (by positivity) (fun _ hw _ hw' =>
      rectangle_determinant_bound he hRpos.le hWpos.le hw hw') hsmall
    (fun _ hz => rectangle_norm_bound he hWpos.le hWR hz)
    (ε := d*Real.log (s.period : ℝ)/2) (a := d^2*s.primes.card/64) (h := h)
  · positivity
  · rw [← s.log_period]
    have hh := rectangle_log_excess hd hd1.le hlogT hlogP hlarge
    linarith
  · positivity
  · have hc : d^3 ≤ d^2 := by nlinarith [sq_nonneg d, mul_nonneg (sq_nonneg d) (by linarith : 0 ≤ 1-d)]
    have hh := mul_le_mul_of_nonneg_right hc hr'.le
    nlinarith [mul_nonneg (sq_nonneg d) hr'.le]
  · exact rectangle_hoeffding_exponent hr' hd.le (by linarith) hlogP hV hVup
  · exact rectangle_cube_growth hd hd1.le hlarge

end GaussianMoat

end OAI