Theorem: le_CarlesonOperatorReal' (Carleson/Theorem1_1/Control_Approximation_Effect.lean)

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
⊢ ∀ x ∈ Set.Icc 0 (2 * Real.pi),
    ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo 0 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ ≤
      T' f x + T' (⇑(starRingEnd ℂ) ∘ f) x
Tactic:
intro x hx
State after:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
⊢ ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo 0 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ ≤
    T' f x + T' (⇑(starRingEnd ℂ) ∘ f) x

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
⊢ ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo 0 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ ≤
    T' f x + T' (⇑(starRingEnd ℂ) ∘ f) x
Tactic:
set s : ℕ → Set ℝ := fun n ↦ {y | dist x y ∈ Set.Ioo (1 / (n + 2 : ℝ)) 1} with sdef
State after:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
⊢ ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo 0 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ ≤
    T' f x + T' (⇑(starRingEnd ℂ) ∘ f) x

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
⊢ ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo 0 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ ≤
    T' f x + T' (⇑(starRingEnd ℂ) ∘ f) x
Tactic:
have hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n := by
  ext y
  constructor
  . intro hy
    rw [Set.mem_setOf_eq, Set.mem_Ioo] at hy
    obtain ⟨n, hn⟩ := exists_nat_gt (1 / dist x y)
    simp
    use n
    rw [sdef]
    simp
    constructor
    . rw [inv_lt, inv_eq_one_div]
      apply lt_trans hn
      linarith
      linarith
      exact hy.1
    . exact hy.2
  . intro hy
    simp at hy
    rcases hy with ⟨n, hn⟩
    rw [sdef] at hn
    simp at hn
    constructor
    . apply lt_trans' hn.1
      norm_num
      linarith
    . exact hn.2
State after:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
⊢ ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo 0 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ ≤
    T' f x + T' (⇑(starRingEnd ℂ) ∘ f) x

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
⊢ ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo 0 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ ≤
    T' f x + T' (⇑(starRingEnd ℂ) ∘ f) x
Tactic:
have : Tendsto (fun i => ∫ y in s i, f y * (max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop (𝓝 (∫ y in ⋃ n, s n, f y * (max (1 - |x - y|) 0) * dirichletKernel' N (x - y))) := by
  apply MeasureTheory.tendsto_setIntegral_of_monotone
  . intro n
    exact annulus_measurableSet
  . intro n m nlem
    simp
    intro y hy
    rw [sdef]
    rw [sdef] at hy
    simp
    simp at hy
    constructor
    . apply lt_of_le_of_lt _ hy.1
      rw [inv_le_inv]
      norm_cast
      all_goals linarith
    . exact hy.2
  . rw [← hs]
    exact integrableOn_mul_dirichletKernel'_specific hx hf
State after:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
⊢ ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo 0 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ ≤
    T' f x + T' (⇑(starRingEnd ℂ) ∘ f) x

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
⊢ ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo 0 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ ≤
    T' f x + T' (⇑(starRingEnd ℂ) ∘ f) x
Tactic:
calc ENNReal.ofNNReal ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo 0 1}, f y * (max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊
  _ = ‖∫ y in ⋃ n, s n, f y * (max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ := by
    congr
  _ ≤ ⨆ (i : ℕ), ↑‖∫ y in s i, f y * (max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ := by
    apply le_iSup_of_tendsto
    rw [ENNReal.tendsto_coe]
    apply Tendsto.nnnorm this
  _ ≤ ⨆ (r : ℝ) (_ : 0 < r) (_ : r < 1), ↑‖∫ y in {y | dist x y ∈ Set.Ioo r 1}, f y * (max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ := by
    apply iSup_le
    intro n
    apply le_iSup_of_le (1 / (n + 2 : ℝ))
    apply le_iSup₂_of_le (by simp; linarith) (by rw [div_lt_iff] <;> linarith)
    rfl
  _ = ⨆ (r : ℝ) (_ : 0 < r) (_ : r < 1), ↑‖∫ y in {y | dist x y ∈ Set.Ioo r 1}, f y * (exp (I * (-(Int.ofNat N) * x)) * K x y * exp (I * N * y) + (starRingEnd ℂ) (exp (I * (-(Int.ofNat N) * x)) * K x y * exp (I * (Int.ofNat N) * y)))‖₊ := by
    apply iSup_congr
    intro r
    apply iSup_congr
    intro _
    apply iSup_congr
    intro _
    congr
    ext y
    rw [mul_assoc, dirichlet_Hilbert_eq]
    norm_cast
  _ ≤ ⨆ (n : ℤ) (r : ℝ) (_ : 0 < r) (_ : r < 1), ↑‖∫ y in {y | dist x y ∈ Set.Ioo r 1}, f y * (exp (I * (-n * x)) * K x y * exp (I * n * y) + (starRingEnd ℂ) (exp (I * (-n * x)) * K x y * exp (I * n * y)))‖₊ := by
    let F : ℤ → ENNReal := fun (n : ℤ) ↦ ⨆ (r : ℝ) (_ : 0 < r) (_ : r < 1), ↑‖∫ y in {y | dist x y ∈ Set.Ioo r 1}, f y * (exp (I * (-n * x)) * K x y * exp (I * n * y) + (starRingEnd ℂ) (exp (I * (-n * x)) * K x y * exp (I * n * y)))‖₊
    apply le_iSup F ((Int.ofNat N))
  _ ≤ ⨆ (n : ℤ) (r : ℝ) (_ : 0 < r) (_ : r < 1), (  ↑‖∫ y in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * exp (I * n * y)‖₊
                                                  + ↑‖∫ y in {y | dist x y ∈ Set.Ioo r 1}, ((starRingEnd ℂ) ∘ f) y * K x y * exp (I * n * y)‖₊) := by
    apply iSup₂_mono
    intro n r
    apply iSup₂_mono
    intro rpos rle1
    norm_cast
    push_cast
    calc ‖∫ y in {y | dist x y ∈ Set.Ioo r 1}, f y * (exp (I * (-n * x)) * K x y * exp (I * n * y) + (starRingEnd ℂ) (exp (I * (-n * x)) * K x y * exp (I * n * y)))‖₊
      _ = ‖∫ y in {y | dist x y ∈ Set.Ioo r 1}, f y * (exp (I * (-n * x)) * K x y * exp (I * n * y)) + f y * (starRingEnd ℂ) (exp (I * (-n * x)) * K x y * exp (I * n * y))‖₊ := by
        congr
        ext y
        rw [mul_add]
      _ = ‖ (∫ y in {y | dist x y ∈ Set.Ioo r 1}, f y * (exp (I * (-n * x)) * K x y * exp (I * n * y)))
           + ∫ y in {y | dist x y ∈ Set.Ioo r 1}, f y * (starRingEnd ℂ) (exp (I * (-n * x)) * K x y * exp (I * n * y))‖₊ := by
        congr
        have measurable₁ : Measurable fun x_1 ↦ (I * (-↑n * ↑x)).exp * K x x_1 * (I * ↑n * ↑x_1).exp := by
          apply Measurable.mul
          apply Measurable.mul
          measurability
          apply Measurable.of_uncurry_left
          exact Hilbert_kernel_measurable
          measurability
        have boundedness₁ {y : ℝ} (h : r ≤ dist x y) : ‖(I * (-↑n * ↑x)).exp * K x y * (I * ↑n * ↑y).exp‖ ≤ (2 ^ (2 : ℝ) / (2 * r)) := by
          calc ‖(I * (-↑n * ↑x)).exp * K x y * (I * ↑n * ↑y).exp‖
            _ = ‖(I * (-↑n * ↑x)).exp‖ * ‖K x y‖ * ‖(I * ↑n * ↑y).exp‖ := by
              rw [norm_mul, norm_mul]
            _ ≤ 1 * (2 ^ (2 : ℝ) / (2 * |x - y|)) * 1 := by
              gcongr
              . rw [norm_eq_abs, mul_comm]
                norm_cast
                rw [abs_exp_ofReal_mul_I]
              . apply Hilbert_kernel_bound
              . rw [norm_eq_abs, mul_assoc, mul_comm]
                norm_cast
                rw [abs_exp_ofReal_mul_I]
            _ ≤ (2 ^ (2 : ℝ) / (2 * r)) := by
              rw [one_mul, mul_one, ← Real.dist_eq]
              gcongr
        have integrable₁ := (integrable_annulus hx hf rpos.le rle1)
        rw [MeasureTheory.integral_add]
        . conv => pattern ((f _) * _); rw [mul_comm]
          apply MeasureTheory.Integrable.bdd_mul' integrable₁ measurable₁.aestronglyMeasurable
          . rw [MeasureTheory.ae_restrict_iff' annulus_measurableSet]
            apply eventually_of_forall
            intro y hy
            exact boundedness₁ hy.1.le
        . conv => pattern ((f _) * _); rw [mul_comm]
          apply MeasureTheory.Integrable.bdd_mul' integrable₁
          . apply Measurable.aestronglyMeasurable
            apply Measurable.comp continuous_star.measurable measurable₁
          . rw [MeasureTheory.ae_restrict_iff' annulus_measurableSet]
            apply eventually_of_forall
            intro y hy
            rw [RCLike.norm_conj]
            exact boundedness₁ hy.1.le
      _ ≤   ‖∫ y in {y | dist x y ∈ Set.Ioo r 1}, f y * (exp (I * (-n * x)) * K x y * exp (I * n * y))‖₊
          + ‖∫ y in {y | dist x y ∈ Set.Ioo r 1}, f y * (starRingEnd ℂ) (exp (I * (-n * x)) * K x y * exp (I * n * y))‖₊ := by
        apply nnnorm_add_le
      _ =   ‖∫ y in {y | dist x y ∈ Set.Ioo r 1}, exp (I * (-n * x)) * (f y * K x y * exp (I * n * y))‖₊
          + ‖∫ y in {y | dist x y ∈ Set.Ioo r 1}, exp (I * (-n * x)) * (((starRingEnd ℂ) ∘ f) y *  K x y * exp (I * n * y))‖₊ := by
          congr 1
          . congr
            ext y
            ring
          . rw [←nnnorm_star, ←starRingEnd_apply, ←integral_conj]
            congr
            ext y
            simp
            ring
      _ =   ‖∫ y in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * exp (I * n * y)‖₊
          + ‖∫ y in {y | dist x y ∈ Set.Ioo r 1}, ((starRingEnd ℂ) ∘ f) y * K x y * exp (I * n * y)‖₊ := by
        rw [← NNReal.coe_inj]
        push_cast
        norm_cast
        congr 1 <;>
        . rw [MeasureTheory.integral_mul_left, norm_mul, norm_eq_abs, mul_comm I, abs_exp_ofReal_mul_I, one_mul]
  _ ≤ T' f x + T' ((starRingEnd ℂ) ∘ f) x := by
    rw [CarlesonOperatorReal', CarlesonOperatorReal']
    apply iSup₂_le
    intro n r
    apply iSup₂_le
    intro rpos rle1
    gcongr <;>
    . apply le_iSup₂_of_le n r
      apply le_iSup₂_of_le rpos rle1
      trivial
State after:
no goals

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
⊢ {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
Tactic:
ext y
State after:
case h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
⊢ y ∈ {y | dist x y ∈ Set.Ioo 0 1} ↔ y ∈ ⋃ n, s n

State before:
case h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
⊢ y ∈ {y | dist x y ∈ Set.Ioo 0 1} ↔ y ∈ ⋃ n, s n
Tactic:
constructor
State after:
case h.mp
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
⊢ y ∈ {y | dist x y ∈ Set.Ioo 0 1} → y ∈ ⋃ n, s n

case h.mpr
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
⊢ y ∈ ⋃ n, s n → y ∈ {y | dist x y ∈ Set.Ioo 0 1}

State before:
case h.mp
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
⊢ y ∈ {y | dist x y ∈ Set.Ioo 0 1} → y ∈ ⋃ n, s n

case h.mpr
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
⊢ y ∈ ⋃ n, s n → y ∈ {y | dist x y ∈ Set.Ioo 0 1}
Tactic:
. intro hy
  rw [Set.mem_setOf_eq, Set.mem_Ioo] at hy
  obtain ⟨n, hn⟩ := exists_nat_gt (1 / dist x y)
  simp
  use n
  rw [sdef]
  simp
  constructor
  . rw [inv_lt, inv_eq_one_div]
    apply lt_trans hn
    linarith
    linarith
    exact hy.1
  . exact hy.2
State after:
case h.mpr
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
⊢ y ∈ ⋃ n, s n → y ∈ {y | dist x y ∈ Set.Ioo 0 1}

State before:
case h.mpr
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
⊢ y ∈ ⋃ n, s n → y ∈ {y | dist x y ∈ Set.Ioo 0 1}
Tactic:
. intro hy
  simp at hy
  rcases hy with ⟨n, hn⟩
  rw [sdef] at hn
  simp at hn
  constructor
  . apply lt_trans' hn.1
    norm_num
    linarith
  . exact hn.2
State after:
no goals

State before:
case h.mp
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
⊢ y ∈ {y | dist x y ∈ Set.Ioo 0 1} → y ∈ ⋃ n, s n
Tactic:
intro hy
State after:
case h.mp
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : y ∈ {y | dist x y ∈ Set.Ioo 0 1}
⊢ y ∈ ⋃ n, s n

State before:
case h.mp
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : y ∈ {y | dist x y ∈ Set.Ioo 0 1}
⊢ y ∈ ⋃ n, s n
Tactic:
rw [Set.mem_setOf_eq, Set.mem_Ioo] at hy
State after:
case h.mp
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
⊢ y ∈ ⋃ n, s n

State before:
case h.mp
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
⊢ y ∈ ⋃ n, s n
Tactic:
obtain ⟨n, hn⟩ := exists_nat_gt (1 / dist x y)
State after:
case h.mp.intro
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ y ∈ ⋃ n, s n

State before:
case h.mp.intro
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ y ∈ ⋃ n, s n
Tactic:
simp
State after:
case h.mp.intro
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ ∃ i, y ∈ s i

State before:
case h.mp.intro
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ ∃ i, y ∈ s i
Tactic:
use n
State after:
case h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ y ∈ s n

State before:
case h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ y ∈ s n
Tactic:
rw [sdef]
State after:
case h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ y ∈ (fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}) n

State before:
case h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ y ∈ (fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}) n
Tactic:
simp
State after:
case h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1

State before:
case h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
Tactic:
constructor
State after:
case h.left
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ (↑n + 2)⁻¹ < dist x y

case h.right
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ dist x y < 1

State before:
case h.left
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ (↑n + 2)⁻¹ < dist x y

case h.right
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ dist x y < 1
Tactic:
. rw [inv_lt, inv_eq_one_div]
  apply lt_trans hn
  linarith
  linarith
  exact hy.1
State after:
case h.right
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ dist x y < 1

State before:
case h.right
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ dist x y < 1
Tactic:
. exact hy.2
State after:
no goals

State before:
case h.left
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ (↑n + 2)⁻¹ < dist x y
Tactic:
rw [inv_lt, inv_eq_one_div]
State after:
case h.left
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ 1 / dist x y < ↑n + 2

case h.left.ha
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ 0 < ↑n + 2

case h.left.hb
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ 0 < dist x y

State before:
case h.left
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ 1 / dist x y < ↑n + 2

case h.left.ha
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ 0 < ↑n + 2

case h.left.hb
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ 0 < dist x y
Tactic:
apply lt_trans hn
State after:
case h.left
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ ↑n < ↑n + 2

case h.left.ha
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ 0 < ↑n + 2

case h.left.hb
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ 0 < dist x y

State before:
case h.left
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ ↑n < ↑n + 2

case h.left.ha
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ 0 < ↑n + 2

case h.left.hb
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ 0 < dist x y
Tactic:
linarith
State after:
case h.left.ha
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ 0 < ↑n + 2

case h.left.hb
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ 0 < dist x y

State before:
case h.left.ha
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ 0 < ↑n + 2

case h.left.hb
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ 0 < dist x y
Tactic:
linarith
State after:
case h.left.hb
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ 0 < dist x y

State before:
case h.left.hb
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ 0 < dist x y
Tactic:
exact hy.1
State after:
no goals

State before:
case h.right
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : 0 < dist x y ∧ dist x y < 1
n : ℕ
hn : 1 / dist x y < ↑n
⊢ dist x y < 1
Tactic:
exact hy.2
State after:
no goals

State before:
case h.mpr
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
⊢ y ∈ ⋃ n, s n → y ∈ {y | dist x y ∈ Set.Ioo 0 1}
Tactic:
intro hy
State after:
case h.mpr
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : y ∈ ⋃ n, s n
⊢ y ∈ {y | dist x y ∈ Set.Ioo 0 1}

State before:
case h.mpr
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : y ∈ ⋃ n, s n
⊢ y ∈ {y | dist x y ∈ Set.Ioo 0 1}
Tactic:
simp at hy
State after:
case h.mpr
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : ∃ i, y ∈ s i
⊢ y ∈ {y | dist x y ∈ Set.Ioo 0 1}

State before:
case h.mpr
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
hy : ∃ i, y ∈ s i
⊢ y ∈ {y | dist x y ∈ Set.Ioo 0 1}
Tactic:
rcases hy with ⟨n, hn⟩
State after:
case h.mpr.intro
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
n : ℕ
hn : y ∈ s n
⊢ y ∈ {y | dist x y ∈ Set.Ioo 0 1}

State before:
case h.mpr.intro
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
n : ℕ
hn : y ∈ s n
⊢ y ∈ {y | dist x y ∈ Set.Ioo 0 1}
Tactic:
rw [sdef] at hn
State after:
case h.mpr.intro
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
n : ℕ
hn : y ∈ (fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}) n
⊢ y ∈ {y | dist x y ∈ Set.Ioo 0 1}

State before:
case h.mpr.intro
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
n : ℕ
hn : y ∈ (fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}) n
⊢ y ∈ {y | dist x y ∈ Set.Ioo 0 1}
Tactic:
simp at hn
State after:
case h.mpr.intro
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
n : ℕ
hn : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ y ∈ {y | dist x y ∈ Set.Ioo 0 1}

State before:
case h.mpr.intro
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
n : ℕ
hn : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ y ∈ {y | dist x y ∈ Set.Ioo 0 1}
Tactic:
constructor
State after:
case h.mpr.intro.left
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
n : ℕ
hn : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ 0 < dist x y

case h.mpr.intro.right
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
n : ℕ
hn : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ dist x y < 1

State before:
case h.mpr.intro.left
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
n : ℕ
hn : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ 0 < dist x y

case h.mpr.intro.right
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
n : ℕ
hn : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ dist x y < 1
Tactic:
. apply lt_trans' hn.1
  norm_num
  linarith
State after:
case h.mpr.intro.right
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
n : ℕ
hn : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ dist x y < 1

State before:
case h.mpr.intro.right
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
n : ℕ
hn : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ dist x y < 1
Tactic:
. exact hn.2
State after:
no goals

State before:
case h.mpr.intro.left
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
n : ℕ
hn : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ 0 < dist x y
Tactic:
apply lt_trans' hn.1
State after:
case h.mpr.intro.left
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
n : ℕ
hn : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ 0 < (↑n + 2)⁻¹

State before:
case h.mpr.intro.left
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
n : ℕ
hn : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ 0 < (↑n + 2)⁻¹
Tactic:
norm_num
State after:
case h.mpr.intro.left
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
n : ℕ
hn : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ 0 < ↑n + 2

State before:
case h.mpr.intro.left
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
n : ℕ
hn : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ 0 < ↑n + 2
Tactic:
linarith
State after:
no goals

State before:
case h.mpr.intro.right
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
y : ℝ
n : ℕ
hn : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ dist x y < 1
Tactic:
exact hn.2
State after:
no goals

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
⊢ Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
Tactic:
apply MeasureTheory.tendsto_setIntegral_of_monotone
State after:
case hsm
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
⊢ ∀ (i : ℕ), MeasurableSet (s i)

case h_mono
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
⊢ Monotone fun i => s i

case hfi
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
⊢ MeasureTheory.IntegrableOn (fun x_1 => f x_1 * ↑(max (1 - |x - x_1|) 0) * dirichletKernel' N (x - x_1)) (⋃ n, s n)
    MeasureTheory.volume

State before:
case hsm
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
⊢ ∀ (i : ℕ), MeasurableSet (s i)

case h_mono
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
⊢ Monotone fun i => s i

case hfi
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
⊢ MeasureTheory.IntegrableOn (fun x_1 => f x_1 * ↑(max (1 - |x - x_1|) 0) * dirichletKernel' N (x - x_1)) (⋃ n, s n)
    MeasureTheory.volume
Tactic:
. intro n
  exact annulus_measurableSet
State after:
case h_mono
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
⊢ Monotone fun i => s i

case hfi
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
⊢ MeasureTheory.IntegrableOn (fun x_1 => f x_1 * ↑(max (1 - |x - x_1|) 0) * dirichletKernel' N (x - x_1)) (⋃ n, s n)
    MeasureTheory.volume

State before:
case h_mono
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
⊢ Monotone fun i => s i

case hfi
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
⊢ MeasureTheory.IntegrableOn (fun x_1 => f x_1 * ↑(max (1 - |x - x_1|) 0) * dirichletKernel' N (x - x_1)) (⋃ n, s n)
    MeasureTheory.volume
Tactic:
. intro n m nlem
  simp
  intro y hy
  rw [sdef]
  rw [sdef] at hy
  simp
  simp at hy
  constructor
  . apply lt_of_le_of_lt _ hy.1
    rw [inv_le_inv]
    norm_cast
    all_goals linarith
  . exact hy.2
State after:
case hfi
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
⊢ MeasureTheory.IntegrableOn (fun x_1 => f x_1 * ↑(max (1 - |x - x_1|) 0) * dirichletKernel' N (x - x_1)) (⋃ n, s n)
    MeasureTheory.volume

State before:
case hfi
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
⊢ MeasureTheory.IntegrableOn (fun x_1 => f x_1 * ↑(max (1 - |x - x_1|) 0) * dirichletKernel' N (x - x_1)) (⋃ n, s n)
    MeasureTheory.volume
Tactic:
. rw [← hs]
  exact integrableOn_mul_dirichletKernel'_specific hx hf
State after:
no goals

State before:
case hsm
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
⊢ ∀ (i : ℕ), MeasurableSet (s i)
Tactic:
intro n
State after:
case hsm
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n : ℕ
⊢ MeasurableSet (s n)

State before:
case hsm
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n : ℕ
⊢ MeasurableSet (s n)
Tactic:
exact annulus_measurableSet
State after:
no goals

State before:
case h_mono
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
⊢ Monotone fun i => s i
Tactic:
intro n m nlem
State after:
case h_mono
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
⊢ (fun i => s i) n ≤ (fun i => s i) m

State before:
case h_mono
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
⊢ (fun i => s i) n ≤ (fun i => s i) m
Tactic:
simp
State after:
case h_mono
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
⊢ s n ⊆ s m

State before:
case h_mono
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
⊢ s n ⊆ s m
Tactic:
intro y hy
State after:
case h_mono
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : y ∈ s n
⊢ y ∈ s m

State before:
case h_mono
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : y ∈ s n
⊢ y ∈ s m
Tactic:
rw [sdef]
State after:
case h_mono
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : y ∈ s n
⊢ y ∈ (fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}) m

State before:
case h_mono
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : y ∈ s n
⊢ y ∈ (fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}) m
Tactic:
rw [sdef] at hy
State after:
case h_mono
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : y ∈ (fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}) n
⊢ y ∈ (fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}) m

State before:
case h_mono
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : y ∈ (fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}) n
⊢ y ∈ (fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}) m
Tactic:
simp
State after:
case h_mono
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : y ∈ (fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}) n
⊢ (↑m + 2)⁻¹ < dist x y ∧ dist x y < 1

State before:
case h_mono
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : y ∈ (fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}) n
⊢ (↑m + 2)⁻¹ < dist x y ∧ dist x y < 1
Tactic:
simp at hy
State after:
case h_mono
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ (↑m + 2)⁻¹ < dist x y ∧ dist x y < 1

State before:
case h_mono
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ (↑m + 2)⁻¹ < dist x y ∧ dist x y < 1
Tactic:
constructor
State after:
case h_mono.left
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ (↑m + 2)⁻¹ < dist x y

case h_mono.right
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ dist x y < 1

State before:
case h_mono.left
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ (↑m + 2)⁻¹ < dist x y

case h_mono.right
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ dist x y < 1
Tactic:
. apply lt_of_le_of_lt _ hy.1
  rw [inv_le_inv]
  norm_cast
  all_goals linarith
State after:
case h_mono.right
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ dist x y < 1

State before:
case h_mono.right
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ dist x y < 1
Tactic:
. exact hy.2
State after:
no goals

State before:
case h_mono.left
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ (↑m + 2)⁻¹ < dist x y
Tactic:
apply lt_of_le_of_lt _ hy.1
State after:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ (↑m + 2)⁻¹ ≤ (↑n + 2)⁻¹

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ (↑m + 2)⁻¹ ≤ (↑n + 2)⁻¹
Tactic:
rw [inv_le_inv]
State after:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ ↑n + 2 ≤ ↑m + 2

case ha
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ 0 < ↑m + 2

case hb
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ 0 < ↑n + 2

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ ↑n + 2 ≤ ↑m + 2

case ha
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ 0 < ↑m + 2

case hb
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ 0 < ↑n + 2
Tactic:
norm_cast
State after:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ n + 2 ≤ m + 2

case ha
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ 0 < ↑m + 2

case hb
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ 0 < ↑n + 2

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ n + 2 ≤ m + 2

case ha
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ 0 < ↑m + 2

case hb
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ 0 < ↑n + 2
Tactic:
all_goals linarith
State after:
no goals

State before:
case hb
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ 0 < ↑n + 2
Tactic:
linarith
State after:
no goals

State before:
case h_mono.right
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
n m : ℕ
nlem : n ≤ m
y : ℝ
hy : (↑n + 2)⁻¹ < dist x y ∧ dist x y < 1
⊢ dist x y < 1
Tactic:
exact hy.2
State after:
no goals

State before:
case hfi
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
⊢ MeasureTheory.IntegrableOn (fun x_1 => f x_1 * ↑(max (1 - |x - x_1|) 0) * dirichletKernel' N (x - x_1)) (⋃ n, s n)
    MeasureTheory.volume
Tactic:
rw [← hs]
State after:
case hfi
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
⊢ MeasureTheory.IntegrableOn (fun x_1 => f x_1 * ↑(max (1 - |x - x_1|) 0) * dirichletKernel' N (x - x_1))
    {y | dist x y ∈ Set.Ioo 0 1} MeasureTheory.volume

State before:
case hfi
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
⊢ MeasureTheory.IntegrableOn (fun x_1 => f x_1 * ↑(max (1 - |x - x_1|) 0) * dirichletKernel' N (x - x_1))
    {y | dist x y ∈ Set.Ioo 0 1} MeasureTheory.volume
Tactic:
exact integrableOn_mul_dirichletKernel'_specific hx hf
State after:
no goals

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
⊢ ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo 0 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ =
    ↑‖∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊
Tactic:
congr
State after:
no goals

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
⊢ ↑‖∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ ≤
    ⨆ i, ↑‖∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊
Tactic:
apply le_iSup_of_tendsto
State after:
case ha
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
⊢ Tendsto (fun i => ↑‖∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊) atTop
    (𝓝 ↑‖∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊)

State before:
case ha
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
⊢ Tendsto (fun i => ↑‖∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊) atTop
    (𝓝 ↑‖∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊)
Tactic:
rw [ENNReal.tendsto_coe]
State after:
case ha
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
⊢ Tendsto (fun i => ‖∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊) atTop
    (𝓝 ‖∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊)

State before:
case ha
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
⊢ Tendsto (fun i => ‖∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊) atTop
    (𝓝 ‖∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊)
Tactic:
apply Tendsto.nnnorm this
State after:
no goals

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
⊢ ⨆ i, ↑‖∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ ≤
    ⨆ r,
      ⨆ (_ : 0 < r),
        ⨆ (_ : r < 1),
          ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊
Tactic:
apply iSup_le
State after:
case h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
⊢ ∀ (i : ℕ),
    ↑‖∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ ≤
      ⨆ r,
        ⨆ (_ : 0 < r),
          ⨆ (_ : r < 1),
            ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊

State before:
case h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
⊢ ∀ (i : ℕ),
    ↑‖∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ ≤
      ⨆ r,
        ⨆ (_ : 0 < r),
          ⨆ (_ : r < 1),
            ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊
Tactic:
intro n
State after:
case h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℕ
⊢ ↑‖∫ (y : ℝ) in s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ ≤
    ⨆ r,
      ⨆ (_ : 0 < r),
        ⨆ (_ : r < 1),
          ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊

State before:
case h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℕ
⊢ ↑‖∫ (y : ℝ) in s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ ≤
    ⨆ r,
      ⨆ (_ : 0 < r),
        ⨆ (_ : r < 1),
          ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊
Tactic:
apply le_iSup_of_le (1 / (n + 2 : ℝ))
State after:
case h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℕ
⊢ ↑‖∫ (y : ℝ) in s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ ≤
    ⨆ (_ : 0 < 1 / (↑n + 2)),
      ⨆ (_ : 1 / (↑n + 2) < 1),
        ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1},
              f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊

State before:
case h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℕ
⊢ ↑‖∫ (y : ℝ) in s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ ≤
    ⨆ (_ : 0 < 1 / (↑n + 2)),
      ⨆ (_ : 1 / (↑n + 2) < 1),
        ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1},
              f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊
Tactic:
apply le_iSup₂_of_le (by simp; linarith) (by rw [div_lt_iff] <;> linarith)
State after:
case h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℕ
⊢ ↑‖∫ (y : ℝ) in s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ ≤
    ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1},
          f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊

State before:
case h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℕ
⊢ ↑‖∫ (y : ℝ) in s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ ≤
    ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1},
          f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊
Tactic:
rfl
State after:
no goals

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℕ
⊢ 0 < 1 / (↑n + 2)
Tactic:
simp
State after:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℕ
⊢ 0 < ↑n + 2

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℕ
⊢ 0 < ↑n + 2
Tactic:
linarith
State after:
no goals

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℕ
⊢ 1 / (↑n + 2) < 1
Tactic:
rw [div_lt_iff] <;> linarith
State after:
no goals

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
⊢ ⨆ r,
      ⨆ (_ : 0 < r),
        ⨆ (_ : r < 1),
          ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ =
    ⨆ r,
      ⨆ (_ : 0 < r),
        ⨆ (_ : r < 1),
          ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
                f y *
                  (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑N * ↑y) +
                    (starRingEnd ℂ) (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑(Int.ofNat N) * ↑y)))‖₊
Tactic:
apply iSup_congr
State after:
case h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
⊢ ∀ (i : ℝ),
    ⨆ (_ : 0 < i),
        ⨆ (_ : i < 1),
          ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo i 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ =
      ⨆ (_ : 0 < i),
        ⨆ (_ : i < 1),
          ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo i 1},
                f y *
                  (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑N * ↑y) +
                    (starRingEnd ℂ) (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑(Int.ofNat N) * ↑y)))‖₊

State before:
case h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
⊢ ∀ (i : ℝ),
    ⨆ (_ : 0 < i),
        ⨆ (_ : i < 1),
          ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo i 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ =
      ⨆ (_ : 0 < i),
        ⨆ (_ : i < 1),
          ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo i 1},
                f y *
                  (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑N * ↑y) +
                    (starRingEnd ℂ) (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑(Int.ofNat N) * ↑y)))‖₊
Tactic:
intro r
State after:
case h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
r : ℝ
⊢ ⨆ (_ : 0 < r),
      ⨆ (_ : r < 1),
        ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ =
    ⨆ (_ : 0 < r),
      ⨆ (_ : r < 1),
        ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
              f y *
                (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑N * ↑y) +
                  (starRingEnd ℂ) (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑(Int.ofNat N) * ↑y)))‖₊

State before:
case h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
r : ℝ
⊢ ⨆ (_ : 0 < r),
      ⨆ (_ : r < 1),
        ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ =
    ⨆ (_ : 0 < r),
      ⨆ (_ : r < 1),
        ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
              f y *
                (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑N * ↑y) +
                  (starRingEnd ℂ) (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑(Int.ofNat N) * ↑y)))‖₊
Tactic:
apply iSup_congr
State after:
case h.h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
r : ℝ
⊢ 0 < r →
    ⨆ (_ : r < 1),
        ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ =
      ⨆ (_ : r < 1),
        ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
              f y *
                (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑N * ↑y) +
                  (starRingEnd ℂ) (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑(Int.ofNat N) * ↑y)))‖₊

State before:
case h.h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
r : ℝ
⊢ 0 < r →
    ⨆ (_ : r < 1),
        ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ =
      ⨆ (_ : r < 1),
        ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
              f y *
                (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑N * ↑y) +
                  (starRingEnd ℂ) (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑(Int.ofNat N) * ↑y)))‖₊
Tactic:
intro _
State after:
case h.h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
r : ℝ
i✝ : 0 < r
⊢ ⨆ (_ : r < 1),
      ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ =
    ⨆ (_ : r < 1),
      ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
            f y *
              (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑N * ↑y) +
                (starRingEnd ℂ) (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑(Int.ofNat N) * ↑y)))‖₊

State before:
case h.h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
r : ℝ
i✝ : 0 < r
⊢ ⨆ (_ : r < 1),
      ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ =
    ⨆ (_ : r < 1),
      ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
            f y *
              (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑N * ↑y) +
                (starRingEnd ℂ) (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑(Int.ofNat N) * ↑y)))‖₊
Tactic:
apply iSup_congr
State after:
case h.h.h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
r : ℝ
i✝ : 0 < r
⊢ r < 1 →
    ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ =
      ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
            f y *
              (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑N * ↑y) +
                (starRingEnd ℂ) (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑(Int.ofNat N) * ↑y)))‖₊

State before:
case h.h.h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
r : ℝ
i✝ : 0 < r
⊢ r < 1 →
    ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ =
      ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
            f y *
              (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑N * ↑y) +
                (starRingEnd ℂ) (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑(Int.ofNat N) * ↑y)))‖₊
Tactic:
intro _
State after:
case h.h.h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
r : ℝ
i✝¹ : 0 < r
i✝ : r < 1
⊢ ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ =
    ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
          f y *
            (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑N * ↑y) +
              (starRingEnd ℂ) (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑(Int.ofNat N) * ↑y)))‖₊

State before:
case h.h.h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
r : ℝ
i✝¹ : 0 < r
i✝ : r < 1
⊢ ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)‖₊ =
    ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
          f y *
            (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑N * ↑y) +
              (starRingEnd ℂ) (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑(Int.ofNat N) * ↑y)))‖₊
Tactic:
congr
State after:
case h.h.h.e_a.e_a.e_f
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
r : ℝ
i✝¹ : 0 < r
i✝ : r < 1
⊢ (fun y => f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) = fun y =>
    f y *
      (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑N * ↑y) +
        (starRingEnd ℂ) (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑(Int.ofNat N) * ↑y)))

State before:
case h.h.h.e_a.e_a.e_f
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
r : ℝ
i✝¹ : 0 < r
i✝ : r < 1
⊢ (fun y => f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) = fun y =>
    f y *
      (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑N * ↑y) +
        (starRingEnd ℂ) (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑(Int.ofNat N) * ↑y)))
Tactic:
ext y
State after:
case h.h.h.e_a.e_a.e_f.h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
r : ℝ
i✝¹ : 0 < r
i✝ : r < 1
y : ℝ
⊢ f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y) =
    f y *
      (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑N * ↑y) +
        (starRingEnd ℂ) (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑(Int.ofNat N) * ↑y)))

State before:
case h.h.h.e_a.e_a.e_f.h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
r : ℝ
i✝¹ : 0 < r
i✝ : r < 1
y : ℝ
⊢ f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y) =
    f y *
      (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑N * ↑y) +
        (starRingEnd ℂ) (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑(Int.ofNat N) * ↑y)))
Tactic:
rw [mul_assoc, dirichlet_Hilbert_eq]
State after:
case h.h.h.e_a.e_a.e_f.h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
r : ℝ
i✝¹ : 0 < r
i✝ : r < 1
y : ℝ
⊢ f y *
      (cexp (I * (-↑N * ↑x)) * K x y * cexp (I * ↑N * ↑y) +
        (starRingEnd ℂ) (cexp (I * (-↑N * ↑x)) * K x y * cexp (I * ↑N * ↑y))) =
    f y *
      (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑N * ↑y) +
        (starRingEnd ℂ) (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑(Int.ofNat N) * ↑y)))

State before:
case h.h.h.e_a.e_a.e_f.h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
r : ℝ
i✝¹ : 0 < r
i✝ : r < 1
y : ℝ
⊢ f y *
      (cexp (I * (-↑N * ↑x)) * K x y * cexp (I * ↑N * ↑y) +
        (starRingEnd ℂ) (cexp (I * (-↑N * ↑x)) * K x y * cexp (I * ↑N * ↑y))) =
    f y *
      (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑N * ↑y) +
        (starRingEnd ℂ) (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑(Int.ofNat N) * ↑y)))
Tactic:
norm_cast
State after:
no goals

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
⊢ ⨆ r,
      ⨆ (_ : 0 < r),
        ⨆ (_ : r < 1),
          ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
                f y *
                  (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑N * ↑y) +
                    (starRingEnd ℂ) (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑(Int.ofNat N) * ↑y)))‖₊ ≤
    ⨆ n,
      ⨆ r,
        ⨆ (_ : 0 < r),
          ⨆ (_ : r < 1),
            ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
                  f y *
                    (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y) +
                      (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)))‖₊
Tactic:
let F : ℤ → ENNReal := fun (n : ℤ) ↦ ⨆ (r : ℝ) (_ : 0 < r) (_ : r < 1), ↑‖∫ y in {y | dist x y ∈ Set.Ioo r 1}, f y * (exp (I * (-n * x)) * K x y * exp (I * n * y) + (starRingEnd ℂ) (exp (I * (-n * x)) * K x y * exp (I * n * y)))‖₊
State after:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
F : ℤ → ENNReal :=
  fun n =>
    ⨆ r,
      ⨆ (_ : 0 < r),
        ⨆ (_ : r < 1),
          ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
                f y *
                  (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y) +
                    (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)))‖₊
⊢ ⨆ r,
      ⨆ (_ : 0 < r),
        ⨆ (_ : r < 1),
          ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
                f y *
                  (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑N * ↑y) +
                    (starRingEnd ℂ) (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑(Int.ofNat N) * ↑y)))‖₊ ≤
    ⨆ n,
      ⨆ r,
        ⨆ (_ : 0 < r),
          ⨆ (_ : r < 1),
            ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
                  f y *
                    (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y) +
                      (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)))‖₊

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
F : ℤ → ENNReal :=
  fun n =>
    ⨆ r,
      ⨆ (_ : 0 < r),
        ⨆ (_ : r < 1),
          ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
                f y *
                  (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y) +
                    (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)))‖₊
⊢ ⨆ r,
      ⨆ (_ : 0 < r),
        ⨆ (_ : r < 1),
          ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
                f y *
                  (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑N * ↑y) +
                    (starRingEnd ℂ) (cexp (I * (-↑(Int.ofNat N) * ↑x)) * K x y * cexp (I * ↑(Int.ofNat N) * ↑y)))‖₊ ≤
    ⨆ n,
      ⨆ r,
        ⨆ (_ : 0 < r),
          ⨆ (_ : r < 1),
            ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
                  f y *
                    (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y) +
                      (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)))‖₊
Tactic:
apply le_iSup F ((Int.ofNat N))
State after:
no goals

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
⊢ ⨆ n,
      ⨆ r,
        ⨆ (_ : 0 < r),
          ⨆ (_ : r < 1),
            ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
                  f y *
                    (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y) +
                      (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)))‖₊ ≤
    ⨆ n,
      ⨆ r,
        ⨆ (_ : 0 < r),
          ⨆ (_ : r < 1),
            ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * cexp (I * ↑n * ↑y)‖₊ +
              ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, (⇑(starRingEnd ℂ) ∘ f) y * K x y * cexp (I * ↑n * ↑y)‖₊
Tactic:
apply iSup₂_mono
State after:
case h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
⊢ ∀ (i : ℤ) (j : ℝ),
    ⨆ (_ : 0 < j),
        ⨆ (_ : j < 1),
          ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo j 1},
                f y *
                  (cexp (I * (-↑i * ↑x)) * K x y * cexp (I * ↑i * ↑y) +
                    (starRingEnd ℂ) (cexp (I * (-↑i * ↑x)) * K x y * cexp (I * ↑i * ↑y)))‖₊ ≤
      ⨆ (_ : 0 < j),
        ⨆ (_ : j < 1),
          ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo j 1}, f y * K x y * cexp (I * ↑i * ↑y)‖₊ +
            ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo j 1}, (⇑(starRingEnd ℂ) ∘ f) y * K x y * cexp (I * ↑i * ↑y)‖₊

State before:
case h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
⊢ ∀ (i : ℤ) (j : ℝ),
    ⨆ (_ : 0 < j),
        ⨆ (_ : j < 1),
          ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo j 1},
                f y *
                  (cexp (I * (-↑i * ↑x)) * K x y * cexp (I * ↑i * ↑y) +
                    (starRingEnd ℂ) (cexp (I * (-↑i * ↑x)) * K x y * cexp (I * ↑i * ↑y)))‖₊ ≤
      ⨆ (_ : 0 < j),
        ⨆ (_ : j < 1),
          ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo j 1}, f y * K x y * cexp (I * ↑i * ↑y)‖₊ +
            ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo j 1}, (⇑(starRingEnd ℂ) ∘ f) y * K x y * cexp (I * ↑i * ↑y)‖₊
Tactic:
intro n r
State after:
case h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
⊢ ⨆ (_ : 0 < r),
      ⨆ (_ : r < 1),
        ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
              f y *
                (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y) +
                  (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)))‖₊ ≤
    ⨆ (_ : 0 < r),
      ⨆ (_ : r < 1),
        ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * cexp (I * ↑n * ↑y)‖₊ +
          ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, (⇑(starRingEnd ℂ) ∘ f) y * K x y * cexp (I * ↑n * ↑y)‖₊

State before:
case h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
⊢ ⨆ (_ : 0 < r),
      ⨆ (_ : r < 1),
        ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
              f y *
                (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y) +
                  (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)))‖₊ ≤
    ⨆ (_ : 0 < r),
      ⨆ (_ : r < 1),
        ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * cexp (I * ↑n * ↑y)‖₊ +
          ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, (⇑(starRingEnd ℂ) ∘ f) y * K x y * cexp (I * ↑n * ↑y)‖₊
Tactic:
apply iSup₂_mono
State after:
case h.h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
⊢ 0 < r →
    r < 1 →
      ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
              f y *
                (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y) +
                  (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)))‖₊ ≤
        ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * cexp (I * ↑n * ↑y)‖₊ +
          ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, (⇑(starRingEnd ℂ) ∘ f) y * K x y * cexp (I * ↑n * ↑y)‖₊

State before:
case h.h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
⊢ 0 < r →
    r < 1 →
      ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
              f y *
                (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y) +
                  (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)))‖₊ ≤
        ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * cexp (I * ↑n * ↑y)‖₊ +
          ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, (⇑(starRingEnd ℂ) ∘ f) y * K x y * cexp (I * ↑n * ↑y)‖₊
Tactic:
intro rpos rle1
State after:
case h.h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
          f y *
            (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y) +
              (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)))‖₊ ≤
    ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * cexp (I * ↑n * ↑y)‖₊ +
      ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, (⇑(starRingEnd ℂ) ∘ f) y * K x y * cexp (I * ↑n * ↑y)‖₊

State before:
case h.h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
          f y *
            (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y) +
              (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)))‖₊ ≤
    ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * cexp (I * ↑n * ↑y)‖₊ +
      ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, (⇑(starRingEnd ℂ) ∘ f) y * K x y * cexp (I * ↑n * ↑y)‖₊
Tactic:
norm_cast
State after:
case h.h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
        f y *
          (cexp (I * ↑(↑(-n) * x)) * K x y * cexp (I * ↑n * ↑y) +
            (starRingEnd ℂ) (cexp (I * ↑(↑(-n) * x)) * K x y * cexp (I * ↑n * ↑y)))‖₊ ≤
    ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * cexp (I * ↑n * ↑y)‖₊ +
      ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, (⇑(starRingEnd ℂ) ∘ f) y * K x y * cexp (I * ↑n * ↑y)‖₊

State before:
case h.h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
        f y *
          (cexp (I * ↑(↑(-n) * x)) * K x y * cexp (I * ↑n * ↑y) +
            (starRingEnd ℂ) (cexp (I * ↑(↑(-n) * x)) * K x y * cexp (I * ↑n * ↑y)))‖₊ ≤
    ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * cexp (I * ↑n * ↑y)‖₊ +
      ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, (⇑(starRingEnd ℂ) ∘ f) y * K x y * cexp (I * ↑n * ↑y)‖₊
Tactic:
push_cast
State after:
case h.h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
        f y *
          (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y) +
            (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)))‖₊ ≤
    ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * cexp (I * ↑n * ↑y)‖₊ +
      ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, (⇑(starRingEnd ℂ) ∘ f) y * K x y * cexp (I * ↑n * ↑y)‖₊

State before:
case h.h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
        f y *
          (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y) +
            (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)))‖₊ ≤
    ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * cexp (I * ↑n * ↑y)‖₊ +
      ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, (⇑(starRingEnd ℂ) ∘ f) y * K x y * cexp (I * ↑n * ↑y)‖₊
Tactic:
calc ‖∫ y in {y | dist x y ∈ Set.Ioo r 1}, f y * (exp (I * (-n * x)) * K x y * exp (I * n * y) + (starRingEnd ℂ) (exp (I * (-n * x)) * K x y * exp (I * n * y)))‖₊
  _ = ‖∫ y in {y | dist x y ∈ Set.Ioo r 1}, f y * (exp (I * (-n * x)) * K x y * exp (I * n * y)) + f y * (starRingEnd ℂ) (exp (I * (-n * x)) * K x y * exp (I * n * y))‖₊ := by
    congr
    ext y
    rw [mul_add]
  _ = ‖ (∫ y in {y | dist x y ∈ Set.Ioo r 1}, f y * (exp (I * (-n * x)) * K x y * exp (I * n * y)))
       + ∫ y in {y | dist x y ∈ Set.Ioo r 1}, f y * (starRingEnd ℂ) (exp (I * (-n * x)) * K x y * exp (I * n * y))‖₊ := by
    congr
    have measurable₁ : Measurable fun x_1 ↦ (I * (-↑n * ↑x)).exp * K x x_1 * (I * ↑n * ↑x_1).exp := by
      apply Measurable.mul
      apply Measurable.mul
      measurability
      apply Measurable.of_uncurry_left
      exact Hilbert_kernel_measurable
      measurability
    have boundedness₁ {y : ℝ} (h : r ≤ dist x y) : ‖(I * (-↑n * ↑x)).exp * K x y * (I * ↑n * ↑y).exp‖ ≤ (2 ^ (2 : ℝ) / (2 * r)) := by
      calc ‖(I * (-↑n * ↑x)).exp * K x y * (I * ↑n * ↑y).exp‖
        _ = ‖(I * (-↑n * ↑x)).exp‖ * ‖K x y‖ * ‖(I * ↑n * ↑y).exp‖ := by
          rw [norm_mul, norm_mul]
        _ ≤ 1 * (2 ^ (2 : ℝ) / (2 * |x - y|)) * 1 := by
          gcongr
          . rw [norm_eq_abs, mul_comm]
            norm_cast
            rw [abs_exp_ofReal_mul_I]
          . apply Hilbert_kernel_bound
          . rw [norm_eq_abs, mul_assoc, mul_comm]
            norm_cast
            rw [abs_exp_ofReal_mul_I]
        _ ≤ (2 ^ (2 : ℝ) / (2 * r)) := by
          rw [one_mul, mul_one, ← Real.dist_eq]
          gcongr
    have integrable₁ := (integrable_annulus hx hf rpos.le rle1)
    rw [MeasureTheory.integral_add]
    . conv => pattern ((f _) * _); rw [mul_comm]
      apply MeasureTheory.Integrable.bdd_mul' integrable₁ measurable₁.aestronglyMeasurable
      . rw [MeasureTheory.ae_restrict_iff' annulus_measurableSet]
        apply eventually_of_forall
        intro y hy
        exact boundedness₁ hy.1.le
    . conv => pattern ((f _) * _); rw [mul_comm]
      apply MeasureTheory.Integrable.bdd_mul' integrable₁
      . apply Measurable.aestronglyMeasurable
        apply Measurable.comp continuous_star.measurable measurable₁
      . rw [MeasureTheory.ae_restrict_iff' annulus_measurableSet]
        apply eventually_of_forall
        intro y hy
        rw [RCLike.norm_conj]
        exact boundedness₁ hy.1.le
  _ ≤   ‖∫ y in {y | dist x y ∈ Set.Ioo r 1}, f y * (exp (I * (-n * x)) * K x y * exp (I * n * y))‖₊
      + ‖∫ y in {y | dist x y ∈ Set.Ioo r 1}, f y * (starRingEnd ℂ) (exp (I * (-n * x)) * K x y * exp (I * n * y))‖₊ := by
    apply nnnorm_add_le
  _ =   ‖∫ y in {y | dist x y ∈ Set.Ioo r 1}, exp (I * (-n * x)) * (f y * K x y * exp (I * n * y))‖₊
      + ‖∫ y in {y | dist x y ∈ Set.Ioo r 1}, exp (I * (-n * x)) * (((starRingEnd ℂ) ∘ f) y *  K x y * exp (I * n * y))‖₊ := by
      congr 1
      . congr
        ext y
        ring
      . rw [←nnnorm_star, ←starRingEnd_apply, ←integral_conj]
        congr
        ext y
        simp
        ring
  _ =   ‖∫ y in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * exp (I * n * y)‖₊
      + ‖∫ y in {y | dist x y ∈ Set.Ioo r 1}, ((starRingEnd ℂ) ∘ f) y * K x y * exp (I * n * y)‖₊ := by
    rw [← NNReal.coe_inj]
    push_cast
    norm_cast
    congr 1 <;>
    . rw [MeasureTheory.integral_mul_left, norm_mul, norm_eq_abs, mul_comm I, abs_exp_ofReal_mul_I, one_mul]
State after:
no goals

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
        f y *
          (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y) +
            (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)))‖₊ =
    ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
        f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)) +
          f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))‖₊
Tactic:
congr
State after:
case e_a.e_f
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ (fun y =>
      f y *
        (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y) +
          (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)))) =
    fun y =>
    f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)) +
      f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))

State before:
case e_a.e_f
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ (fun y =>
      f y *
        (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y) +
          (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)))) =
    fun y =>
    f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)) +
      f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))
Tactic:
ext y
State after:
case e_a.e_f.h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
y : ℝ
⊢ f y *
      (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y) +
        (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))) =
    f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)) +
      f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))

State before:
case e_a.e_f.h
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
y : ℝ
⊢ f y *
      (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y) +
        (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))) =
    f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)) +
      f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))
Tactic:
rw [mul_add]
State after:
no goals

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
        f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)) +
          f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))‖₊ =
    ‖(∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))) +
        ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
          f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))‖₊
Tactic:
congr
State after:
case e_a
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
      f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)) +
        f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)) =
    (∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))) +
      ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
        f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))

State before:
case e_a
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
      f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)) +
        f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)) =
    (∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))) +
      ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
        f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))
Tactic:
have measurable₁ : Measurable fun x_1 ↦ (I * (-↑n * ↑x)).exp * K x x_1 * (I * ↑n * ↑x_1).exp := by
  apply Measurable.mul
  apply Measurable.mul
  measurability
  apply Measurable.of_uncurry_left
  exact Hilbert_kernel_measurable
  measurability
State after:
case e_a
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
⊢ ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
      f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)) +
        f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)) =
    (∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))) +
      ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
        f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))

State before:
case e_a
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
⊢ ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
      f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)) +
        f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)) =
    (∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))) +
      ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
        f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))
Tactic:
have boundedness₁ {y : ℝ} (h : r ≤ dist x y) : ‖(I * (-↑n * ↑x)).exp * K x y * (I * ↑n * ↑y).exp‖ ≤ (2 ^ (2 : ℝ) / (2 * r)) := by
  calc ‖(I * (-↑n * ↑x)).exp * K x y * (I * ↑n * ↑y).exp‖
    _ = ‖(I * (-↑n * ↑x)).exp‖ * ‖K x y‖ * ‖(I * ↑n * ↑y).exp‖ := by
      rw [norm_mul, norm_mul]
    _ ≤ 1 * (2 ^ (2 : ℝ) / (2 * |x - y|)) * 1 := by
      gcongr
      . rw [norm_eq_abs, mul_comm]
        norm_cast
        rw [abs_exp_ofReal_mul_I]
      . apply Hilbert_kernel_bound
      . rw [norm_eq_abs, mul_assoc, mul_comm]
        norm_cast
        rw [abs_exp_ofReal_mul_I]
    _ ≤ (2 ^ (2 : ℝ) / (2 * r)) := by
      rw [one_mul, mul_one, ← Real.dist_eq]
      gcongr
State after:
case e_a
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
⊢ ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
      f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)) +
        f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)) =
    (∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))) +
      ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
        f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))

State before:
case e_a
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
⊢ ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
      f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)) +
        f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)) =
    (∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))) +
      ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
        f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))
Tactic:
have integrable₁ := (integrable_annulus hx hf rpos.le rle1)
State after:
case e_a
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
      f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)) +
        f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)) =
    (∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))) +
      ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
        f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))

State before:
case e_a
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
      f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)) +
        f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)) =
    (∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))) +
      ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1},
        f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y))
Tactic:
rw [MeasureTheory.integral_add]
State after:
case e_a.hf
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ MeasureTheory.Integrable (fun y => f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)))
    (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})

case e_a.hg
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ MeasureTheory.Integrable (fun y => f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)))
    (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})

State before:
case e_a.hf
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ MeasureTheory.Integrable (fun y => f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)))
    (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})

case e_a.hg
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ MeasureTheory.Integrable (fun y => f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)))
    (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
Tactic:
. conv => pattern ((f _) * _); rw [mul_comm]
  apply MeasureTheory.Integrable.bdd_mul' integrable₁ measurable₁.aestronglyMeasurable
  . rw [MeasureTheory.ae_restrict_iff' annulus_measurableSet]
    apply eventually_of_forall
    intro y hy
    exact boundedness₁ hy.1.le
State after:
case e_a.hg
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ MeasureTheory.Integrable (fun y => f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)))
    (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})

State before:
case e_a.hg
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ MeasureTheory.Integrable (fun y => f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)))
    (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
Tactic:
. conv => pattern ((f _) * _); rw [mul_comm]
  apply MeasureTheory.Integrable.bdd_mul' integrable₁
  . apply Measurable.aestronglyMeasurable
    apply Measurable.comp continuous_star.measurable measurable₁
  . rw [MeasureTheory.ae_restrict_iff' annulus_measurableSet]
    apply eventually_of_forall
    intro y hy
    rw [RCLike.norm_conj]
    exact boundedness₁ hy.1.le
State after:
no goals

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
Tactic:
apply Measurable.mul
State after:
case hf
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ Measurable fun a => cexp (I * (-↑n * ↑x)) * K x a

case hg
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ Measurable fun a => cexp (I * ↑n * ↑a)

State before:
case hf
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ Measurable fun a => cexp (I * (-↑n * ↑x)) * K x a

case hg
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ Measurable fun a => cexp (I * ↑n * ↑a)
Tactic:
apply Measurable.mul
State after:
case hf.hf
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ Measurable fun a => cexp (I * (-↑n * ↑x))

case hf.hg
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ Measurable fun a => K x a

case hg
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ Measurable fun a => cexp (I * ↑n * ↑a)

State before:
case hf.hf
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ Measurable fun a => cexp (I * (-↑n * ↑x))

case hf.hg
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ Measurable fun a => K x a

case hg
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ Measurable fun a => cexp (I * ↑n * ↑a)
Tactic:
measurability
State after:
case hf.hg
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ Measurable fun a => K x a

case hg
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ Measurable fun a => cexp (I * ↑n * ↑a)

State before:
case hf.hg
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ Measurable fun a => K x a

case hg
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ Measurable fun a => cexp (I * ↑n * ↑a)
Tactic:
apply Measurable.of_uncurry_left
State after:
case hf.hg.hf
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ Measurable (Function.uncurry K)

case hf.hg.m
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ MeasurableSpace ℝ

case hg
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ Measurable fun a => cexp (I * ↑n * ↑a)

State before:
case hf.hg.hf
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ Measurable (Function.uncurry K)

case hf.hg.m
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ MeasurableSpace ℝ

case hg
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ Measurable fun a => cexp (I * ↑n * ↑a)
Tactic:
exact Hilbert_kernel_measurable
State after:
case hg
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ Measurable fun a => cexp (I * ↑n * ↑a)

State before:
case hg
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ Measurable fun a => cexp (I * ↑n * ↑a)
Tactic:
measurability
State after:
no goals

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
Tactic:
calc ‖(I * (-↑n * ↑x)).exp * K x y * (I * ↑n * ↑y).exp‖
  _ = ‖(I * (-↑n * ↑x)).exp‖ * ‖K x y‖ * ‖(I * ↑n * ↑y).exp‖ := by
    rw [norm_mul, norm_mul]
  _ ≤ 1 * (2 ^ (2 : ℝ) / (2 * |x - y|)) * 1 := by
    gcongr
    . rw [norm_eq_abs, mul_comm]
      norm_cast
      rw [abs_exp_ofReal_mul_I]
    . apply Hilbert_kernel_bound
    . rw [norm_eq_abs, mul_assoc, mul_comm]
      norm_cast
      rw [abs_exp_ofReal_mul_I]
  _ ≤ (2 ^ (2 : ℝ) / (2 * r)) := by
    rw [one_mul, mul_one, ← Real.dist_eq]
    gcongr
State after:
no goals

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ = ‖cexp (I * (-↑n * ↑x))‖ * ‖K x y‖ * ‖cexp (I * ↑n * ↑y)‖
Tactic:
rw [norm_mul, norm_mul]
State after:
no goals

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ ‖cexp (I * (-↑n * ↑x))‖ * ‖K x y‖ * ‖cexp (I * ↑n * ↑y)‖ ≤ 1 * (2 ^ 2 / (2 * |x - y|)) * 1
Tactic:
gcongr
State after:
case h₁.h₁
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ ‖cexp (I * (-↑n * ↑x))‖ ≤ 1

case h₁.h₂
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ ‖K x y‖ ≤ 2 ^ 2 / (2 * |x - y|)

case h₂
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ ‖cexp (I * ↑n * ↑y)‖ ≤ 1

State before:
case h₁.h₁
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ ‖cexp (I * (-↑n * ↑x))‖ ≤ 1

case h₁.h₂
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ ‖K x y‖ ≤ 2 ^ 2 / (2 * |x - y|)

case h₂
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ ‖cexp (I * ↑n * ↑y)‖ ≤ 1
Tactic:
. rw [norm_eq_abs, mul_comm]
  norm_cast
  rw [abs_exp_ofReal_mul_I]
State after:
case h₁.h₂
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ ‖K x y‖ ≤ 2 ^ 2 / (2 * |x - y|)

case h₂
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ ‖cexp (I * ↑n * ↑y)‖ ≤ 1

State before:
case h₁.h₂
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ ‖K x y‖ ≤ 2 ^ 2 / (2 * |x - y|)

case h₂
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ ‖cexp (I * ↑n * ↑y)‖ ≤ 1
Tactic:
. apply Hilbert_kernel_bound
State after:
case h₂
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ ‖cexp (I * ↑n * ↑y)‖ ≤ 1

State before:
case h₂
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ ‖cexp (I * ↑n * ↑y)‖ ≤ 1
Tactic:
. rw [norm_eq_abs, mul_assoc, mul_comm]
  norm_cast
  rw [abs_exp_ofReal_mul_I]
State after:
no goals

State before:
case h₁.h₁
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ ‖cexp (I * (-↑n * ↑x))‖ ≤ 1
Tactic:
rw [norm_eq_abs, mul_comm]
State after:
case h₁.h₁
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ Complex.abs (cexp (-↑n * ↑x * I)) ≤ 1

State before:
case h₁.h₁
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ Complex.abs (cexp (-↑n * ↑x * I)) ≤ 1
Tactic:
norm_cast
State after:
case h₁.h₁
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ Complex.abs (cexp (↑(↑(-n) * x) * I)) ≤ 1

State before:
case h₁.h₁
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ Complex.abs (cexp (↑(↑(-n) * x) * I)) ≤ 1
Tactic:
rw [abs_exp_ofReal_mul_I]
State after:
no goals

State before:
case h₁.h₂
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ ‖K x y‖ ≤ 2 ^ 2 / (2 * |x - y|)
Tactic:
apply Hilbert_kernel_bound
State after:
no goals

State before:
case h₂
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ ‖cexp (I * ↑n * ↑y)‖ ≤ 1
Tactic:
rw [norm_eq_abs, mul_assoc, mul_comm]
State after:
case h₂
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ Complex.abs (cexp (↑n * ↑y * I)) ≤ 1

State before:
case h₂
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ Complex.abs (cexp (↑n * ↑y * I)) ≤ 1
Tactic:
norm_cast
State after:
case h₂
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ Complex.abs (cexp (↑(↑n * y) * I)) ≤ 1

State before:
case h₂
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ Complex.abs (cexp (↑(↑n * y) * I)) ≤ 1
Tactic:
rw [abs_exp_ofReal_mul_I]
State after:
no goals

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ 1 * (2 ^ 2 / (2 * |x - y|)) * 1 ≤ 2 ^ 2 / (2 * r)
Tactic:
rw [one_mul, mul_one, ← Real.dist_eq]
State after:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ 2 ^ 2 / (2 * dist x y) ≤ 2 ^ 2 / (2 * r)

State before:
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
y : ℝ
h : r ≤ dist x y
⊢ 2 ^ 2 / (2 * dist x y) ≤ 2 ^ 2 / (2 * r)
Tactic:
gcongr
State after:
no goals

State before:
case e_a.hf
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ MeasureTheory.Integrable (fun y => f y * (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)))
    (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
Tactic:
conv => pattern ((f _) * _); rw [mul_comm]
State after:
case e_a.hf
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ MeasureTheory.Integrable (fun y => cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y) * f y)
    (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})

State before:
case e_a.hf
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ MeasureTheory.Integrable (fun y => cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y) * f y)
    (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
Tactic:
apply MeasureTheory.Integrable.bdd_mul' integrable₁ measurable₁.aestronglyMeasurable
State after:
case e_a.hf
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ ∀ᵐ (x_1 : ℝ) ∂MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1},
    ‖cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)‖ ≤ ?m.492969

f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ ℝ

State before:
case e_a.hf
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ ∀ᵐ (x_1 : ℝ) ∂MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1},
    ‖cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)‖ ≤ ?m.492969

f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ ℝ
Tactic:
. rw [MeasureTheory.ae_restrict_iff' annulus_measurableSet]
  apply eventually_of_forall
  intro y hy
  exact boundedness₁ hy.1.le
State after:
no goals

State before:
case e_a.hf
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ ∀ᵐ (x_1 : ℝ) ∂MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1},
    ‖cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)‖ ≤ ?m.492969
Tactic:
rw [MeasureTheory.ae_restrict_iff' annulus_measurableSet]
State after:
case e_a.hf
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ ∀ᵐ (x_1 : ℝ),
    x_1 ∈ {y | dist x y ∈ Set.Ioo r 1} → ‖cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)‖ ≤ ?m.492969

f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ ℝ

State before:
case e_a.hf
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ ∀ᵐ (x_1 : ℝ),
    x_1 ∈ {y | dist x y ∈ Set.Ioo r 1} → ‖cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)‖ ≤ ?m.492969

f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ ℝ
Tactic:
apply eventually_of_forall
State after:
case e_a.hf.hp
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ ∀ x_1 ∈ {y | dist x y ∈ Set.Ioo r 1}, ‖cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)‖ ≤ ?m.492969

f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ ℝ

State before:
case e_a.hf.hp
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ ∀ x_1 ∈ {y | dist x y ∈ Set.Ioo r 1}, ‖cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)‖ ≤ ?m.492969

f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ ℝ
Tactic:
intro y hy
State after:
case e_a.hf.hp
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
y : ℝ
hy : y ∈ {y | dist x y ∈ Set.Ioo r 1}
⊢ ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ ?m.492969

f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ ℝ

State before:
case e_a.hf.hp
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
y : ℝ
hy : y ∈ {y | dist x y ∈ Set.Ioo r 1}
⊢ ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ ?m.492969

f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ ℝ
Tactic:
exact boundedness₁ hy.1.le
State after:
no goals

State before:
case e_a.hg
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ MeasureTheory.Integrable (fun y => f y * (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)))
    (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
Tactic:
conv => pattern ((f _) * _); rw [mul_comm]
State after:
case e_a.hg
f : ℝ → ℂ
hf : IntervalIntegrable f MeasureTheory.volume (-Real.pi) (3 * Real.pi)
N : ℕ
x : ℝ
hx : x ∈ Set.Icc 0 (2 * Real.pi)
s : ℕ → Set ℝ := fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
sdef : s = fun n => {y | dist x y ∈ Set.Ioo (1 / (↑n + 2)) 1}
hs : {y | dist x y ∈ Set.Ioo 0 1} = ⋃ n, s n
this :
  Tendsto (fun i => ∫ (y : ℝ) in s i, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)) atTop
    (𝓝 (∫ (y : ℝ) in ⋃ n, s n, f y * ↑(max (1 - |x - y|) 0) * dirichletKernel' N (x - y)))
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
measurable₁ : Measurable fun x_1 => cexp (I * (-↑n * ↑x)) * K x x_1 * cexp (I * ↑n * ↑x_1)
boundedness₁ : ∀ {y : ℝ}, r ≤ dist x y → ‖cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)‖ ≤ 2 ^ 2 / (2 * r)
integrable₁ : MeasureTheory.Integrable (fun x => f x) (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})
⊢ MeasureTheory.Integrable (fun y => (starRingEnd ℂ) (cexp (I * (-↑n * ↑x)) * K x y * cexp (I * ↑n * ↑y)) * f y)
    (MeasureTheory.volume.restrict {y | dist x y ∈ Set.Ioo r 1})