url stringclasses 147
values | commit stringclasses 147
values | file_path stringlengths 7 101 | full_name stringlengths 1 94 | start stringlengths 6 10 | end stringlengths 6 11 | tactic stringlengths 1 11.2k | state_before stringlengths 3 2.09M | state_after stringlengths 6 2.09M | input stringlengths 73 2.09M |
|---|---|---|---|---|---|---|---|---|---|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Dirichlet_kernel.lean | partialFourierSum_eq_conv_dirichletKernel | [152, 1] | [191, 35] | ext n | case e_a.e_f.h.e_a.e_f
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
y : ℝ
⊢ (fun n => (fourier (-n)) ↑y * (fourier n) ↑x) = fun n => (fourier n) ↑(x - y) | case e_a.e_f.h.e_a.e_f.h
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
y : ℝ
n : ℤ
⊢ (fourier (-n)) ↑y * (fourier n) ↑x = (fourier n) ↑(x - y) | Please generate a tactic in lean4 to solve the state.
STATE:
case e_a.e_f.h.e_a.e_f
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
y : ℝ
⊢ (fun n => (fourier (-n)) ↑y * (fourier n) ↑x) = fun n => (fourier n) ↑(x - y)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Dirichlet_kernel.lean | partialFourierSum_eq_conv_dirichletKernel | [152, 1] | [191, 35] | rw [fourier_coe_apply, fourier_coe_apply, fourier_coe_apply, ←exp_add] | case e_a.e_f.h.e_a.e_f.h
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
y : ℝ
n : ℤ
⊢ (fourier (-n)) ↑y * (fourier n) ↑x = (fourier n) ↑(x - y) | case e_a.e_f.h.e_a.e_f.h
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
y : ℝ
n : ℤ
⊢ cexp (2 * ↑Real.pi * I * ↑(-n) * ↑y / ↑(2 * Real.pi) + 2 * ↑Real.pi * I * ↑n * ↑x / ↑(2 * Real.pi)) =
cexp (2 * ↑Real.pi * I * ↑n * ↑(x - y) / ↑(2 * Real.pi)) | Please generate a tactic in lean4 to solve the state.
STATE:
case e_a.e_f.h.e_a.e_f.h
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
y : ℝ
n : ℤ
⊢ (fourier (-n)) ↑y * (fourier n) ↑x = (fourier n) ↑(x - y)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Dirichlet_kernel.lean | partialFourierSum_eq_conv_dirichletKernel | [152, 1] | [191, 35] | congr | case e_a.e_f.h.e_a.e_f.h
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
y : ℝ
n : ℤ
⊢ cexp (2 * ↑Real.pi * I * ↑(-n) * ↑y / ↑(2 * Real.pi) + 2 * ↑Real.pi * I * ↑n * ↑x / ↑(2 * Real.pi)) =
cexp (2 * ↑Real.pi * I * ↑n * ↑(x - y) / ↑(2 * Real.pi)) | case e_a.e_f.h.e_a.e_f.h.e_z
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
y : ℝ
n : ℤ
⊢ 2 * ↑Real.pi * I * ↑(-n) * ↑y / ↑(2 * Real.pi) + 2 * ↑Real.pi * I * ↑n * ↑x / ↑(2 * Real.pi) =
2 * ↑Real.pi * I * ↑n * ↑(x - y) / ↑(2 * Real.pi) | Please generate a tactic in lean4 to solve the state.
STATE:
case e_a.e_f.h.e_a.e_f.h
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
y : ℝ
n : ℤ
⊢ cexp (2 * ↑Real.pi * I * ↑(-n) * ↑y / ↑(2 * Real.pi) + 2 * ↑Real.pi * I * ↑n * ↑x / ↑(2 * Real.pi)) =
cexp (2 * ↑Real.pi * I * ↑n * ↑(x - y) / ↑(2 * Real.pi))
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Dirichlet_kernel.lean | partialFourierSum_eq_conv_dirichletKernel | [152, 1] | [191, 35] | field_simp | case e_a.e_f.h.e_a.e_f.h.e_z
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
y : ℝ
n : ℤ
⊢ 2 * ↑Real.pi * I * ↑(-n) * ↑y / ↑(2 * Real.pi) + 2 * ↑Real.pi * I * ↑n * ↑x / ↑(2 * Real.pi) =
2 * ↑Real.pi * I * ↑n * ↑(x - y) / ↑(2 * Real.pi) | case e_a.e_f.h.e_a.e_f.h.e_z
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
y : ℝ
n : ℤ
⊢ (-(2 * ↑Real.pi * I * ↑n * ↑y) + 2 * ↑Real.pi * I * ↑n * ↑x) / (2 * ↑Real.pi) =
2 * ↑Real.pi * I * ↑n * (↑x - ↑y) / (2 * ↑Real.pi) | Please generate a tactic in lean4 to solve the state.
STATE:
case e_a.e_f.h.e_a.e_f.h.e_z
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
y : ℝ
n : ℤ
⊢ 2 * ↑Real.pi * I * ↑(-n) * ↑y / ↑(2 * Real.pi) + 2 * ↑Real.pi * I * ↑n * ↑x / ↑(2 * Real.pi) =
2 * ↑Real.pi * I * ↑n * ↑(x - y) / ↑(2 * Real.pi)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Dirichlet_kernel.lean | partialFourierSum_eq_conv_dirichletKernel | [152, 1] | [191, 35] | rw [mul_sub, sub_eq_neg_add] | case e_a.e_f.h.e_a.e_f.h.e_z
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
y : ℝ
n : ℤ
⊢ (-(2 * ↑Real.pi * I * ↑n * ↑y) + 2 * ↑Real.pi * I * ↑n * ↑x) / (2 * ↑Real.pi) =
2 * ↑Real.pi * I * ↑n * (↑x - ↑y) / (2 * ↑Real.pi) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case e_a.e_f.h.e_a.e_f.h.e_z
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
y : ℝ
n : ℤ
⊢ (-(2 * ↑Real.pi * I * ↑n * ↑y) + 2 * ↑Real.pi * I * ↑n * ↑x) / (2 * ↑Real.pi) =
2 * ↑Real.pi * I * ↑n * (↑x - ↑y) / (2 * ↑Real.pi)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Dirichlet_kernel.lean | partialFourierSum_eq_conv_dirichletKernel' | [193, 1] | [204, 52] | have : (1 / (2 * Real.pi)) * ∫ (y : ℝ) in (0 : ℝ)..(2 * Real.pi), f y * dirichletKernel' N (x - y) = (1 / (2 * Real.pi)) * ∫ (y : ℝ) in (0 : ℝ)..(2 * Real.pi), f y * dirichletKernel N (x - y) := by
congr 1
apply intervalIntegral.integral_congr_ae
apply MeasureTheory.ae_imp_of_ae_restrict
apply MeasureTheory.ae_restrict_of_ae
sorry | f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
⊢ partialFourierSum f N x = 1 / (2 * ↑Real.pi) * ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel' N (x - y) | f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
this :
1 / (2 * ↑Real.pi) * ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel' N (x - y) =
1 / (2 * ↑Real.pi) * ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel N (x - y)
⊢ partialFourierSum f N x = 1 / (2 * ↑Real.pi) * ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel' N (x - y) | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
⊢ partialFourierSum f N x = 1 / (2 * ↑Real.pi) * ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel' N (x - y)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Dirichlet_kernel.lean | partialFourierSum_eq_conv_dirichletKernel' | [193, 1] | [204, 52] | rw [this] | f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
this :
1 / (2 * ↑Real.pi) * ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel' N (x - y) =
1 / (2 * ↑Real.pi) * ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel N (x - y)
⊢ partialFourierSum f N x = 1 / (2 * ↑Real.pi) * ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel' N (x - y) | f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
this :
1 / (2 * ↑Real.pi) * ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel' N (x - y) =
1 / (2 * ↑Real.pi) * ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel N (x - y)
⊢ partialFourierSum f N x = 1 / (2 * ↑Real.pi) * ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel N (x - y) | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
this :
1 / (2 * ↑Real.pi) * ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel' N (x - y) =
1 / (2 * ↑Real.pi) * ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel N (x - y)
⊢ partialFourierSum f N x = 1 / (2 * ↑Real.pi) * ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel' N (x - y)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Dirichlet_kernel.lean | partialFourierSum_eq_conv_dirichletKernel' | [193, 1] | [204, 52] | exact partialFourierSum_eq_conv_dirichletKernel h | f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
this :
1 / (2 * ↑Real.pi) * ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel' N (x - y) =
1 / (2 * ↑Real.pi) * ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel N (x - y)
⊢ partialFourierSum f N x = 1 / (2 * ↑Real.pi) * ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel N (x - y) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
this :
1 / (2 * ↑Real.pi) * ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel' N (x - y) =
1 / (2 * ↑Real.pi) * ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel N (x - y)
⊢ partialFourierSum f N x = 1 / (2 * ↑Real.pi) * ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel N (x - y)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Dirichlet_kernel.lean | partialFourierSum_eq_conv_dirichletKernel' | [193, 1] | [204, 52] | congr 1 | f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
⊢ 1 / (2 * ↑Real.pi) * ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel' N (x - y) =
1 / (2 * ↑Real.pi) * ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel N (x - y) | case e_a
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
⊢ ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel' N (x - y) =
∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel N (x - y) | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
⊢ 1 / (2 * ↑Real.pi) * ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel' N (x - y) =
1 / (2 * ↑Real.pi) * ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel N (x - y)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Dirichlet_kernel.lean | partialFourierSum_eq_conv_dirichletKernel' | [193, 1] | [204, 52] | apply intervalIntegral.integral_congr_ae | case e_a
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
⊢ ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel' N (x - y) =
∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel N (x - y) | case e_a.h
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
⊢ ∀ᵐ (x_1 : ℝ), x_1 ∈ Ι 0 (2 * Real.pi) → f x_1 * dirichletKernel' N (x - x_1) = f x_1 * dirichletKernel N (x - x_1) | Please generate a tactic in lean4 to solve the state.
STATE:
case e_a
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
⊢ ∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel' N (x - y) =
∫ (y : ℝ) in 0 ..2 * Real.pi, f y * dirichletKernel N (x - y)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Dirichlet_kernel.lean | partialFourierSum_eq_conv_dirichletKernel' | [193, 1] | [204, 52] | apply MeasureTheory.ae_imp_of_ae_restrict | case e_a.h
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
⊢ ∀ᵐ (x_1 : ℝ), x_1 ∈ Ι 0 (2 * Real.pi) → f x_1 * dirichletKernel' N (x - x_1) = f x_1 * dirichletKernel N (x - x_1) | case e_a.h.h
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
⊢ ∀ᵐ (x_1 : ℝ) ∂MeasureTheory.volume.restrict (Ι 0 (2 * Real.pi)),
f x_1 * dirichletKernel' N (x - x_1) = f x_1 * dirichletKernel N (x - x_1) | Please generate a tactic in lean4 to solve the state.
STATE:
case e_a.h
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
⊢ ∀ᵐ (x_1 : ℝ), x_1 ∈ Ι 0 (2 * Real.pi) → f x_1 * dirichletKernel' N (x - x_1) = f x_1 * dirichletKernel N (x - x_1)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Dirichlet_kernel.lean | partialFourierSum_eq_conv_dirichletKernel' | [193, 1] | [204, 52] | apply MeasureTheory.ae_restrict_of_ae | case e_a.h.h
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
⊢ ∀ᵐ (x_1 : ℝ) ∂MeasureTheory.volume.restrict (Ι 0 (2 * Real.pi)),
f x_1 * dirichletKernel' N (x - x_1) = f x_1 * dirichletKernel N (x - x_1) | case e_a.h.h.h
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
⊢ ∀ᵐ (x_1 : ℝ), f x_1 * dirichletKernel' N (x - x_1) = f x_1 * dirichletKernel N (x - x_1) | Please generate a tactic in lean4 to solve the state.
STATE:
case e_a.h.h
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
⊢ ∀ᵐ (x_1 : ℝ) ∂MeasureTheory.volume.restrict (Ι 0 (2 * Real.pi)),
f x_1 * dirichletKernel' N (x - x_1) = f x_1 * dirichletKernel N (x - x_1)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Dirichlet_kernel.lean | partialFourierSum_eq_conv_dirichletKernel' | [193, 1] | [204, 52] | sorry | case e_a.h.h.h
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
⊢ ∀ᵐ (x_1 : ℝ), f x_1 * dirichletKernel' N (x - x_1) = f x_1 * dirichletKernel N (x - x_1) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case e_a.h.h.h
f : ℝ → ℂ
N : ℕ
x : ℝ
h : IntervalIntegrable f MeasureTheory.volume 0 (2 * Real.pi)
⊢ ∀ᵐ (x_1 : ℝ), f x_1 * dirichletKernel' N (x - x_1) = f x_1 * dirichletKernel N (x - x_1)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | ext y | x r R : ℝ
r_nonneg : 0 ≤ r
⊢ {y | dist x y ∈ Set.Ioo r R} = Set.Ioo (x - R) (x - r) ∪ Set.Ioo (x + r) (x + R) | case h
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
⊢ y ∈ {y | dist x y ∈ Set.Ioo r R} ↔ y ∈ Set.Ioo (x - R) (x - r) ∪ Set.Ioo (x + r) (x + R) | Please generate a tactic in lean4 to solve the state.
STATE:
x r R : ℝ
r_nonneg : 0 ≤ r
⊢ {y | dist x y ∈ Set.Ioo r R} = Set.Ioo (x - R) (x - r) ∪ Set.Ioo (x + r) (x + R)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | simp | case h
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
⊢ y ∈ {y | dist x y ∈ Set.Ioo r R} ↔ y ∈ Set.Ioo (x - R) (x - r) ∪ Set.Ioo (x + r) (x + R) | case h
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
⊢ r < dist x y ∧ dist x y < R ↔ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R | Please generate a tactic in lean4 to solve the state.
STATE:
case h
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
⊢ y ∈ {y | dist x y ∈ Set.Ioo r R} ↔ y ∈ Set.Ioo (x - R) (x - r) ∪ Set.Ioo (x + r) (x + R)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | rw [Real.dist_eq, lt_abs, abs_lt] | case h
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
⊢ r < dist x y ∧ dist x y < R ↔ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R | case h
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
⊢ (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R ↔ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R | Please generate a tactic in lean4 to solve the state.
STATE:
case h
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
⊢ r < dist x y ∧ dist x y < R ↔ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | constructor | case h
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
⊢ (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R ↔ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R | case h.mp
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
⊢ (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R → x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R
case h.mpr
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
⊢ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R → (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R | Please generate a tactic in lean4 to solve the state.
STATE:
case h
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
⊢ (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R ↔ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | . rintro ⟨(h₀ | h₀), h₁, h₂⟩
. left
constructor <;> linarith
. right
constructor <;> linarith | case h.mp
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
⊢ (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R → x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R
case h.mpr
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
⊢ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R → (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R | case h.mpr
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
⊢ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R → (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mp
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
⊢ (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R → x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R
case h.mpr
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
⊢ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R → (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | . rintro (⟨h₀, h₁⟩ | ⟨h₀, h₁⟩)
. constructor
. left
linarith
. constructor <;> linarith
. constructor
. right
linarith
. constructor <;> linarith | case h.mpr
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
⊢ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R → (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
⊢ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R → (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | rintro ⟨(h₀ | h₀), h₁, h₂⟩ | case h.mp
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
⊢ (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R → x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R | case h.mp.intro.inl.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : r < x - y
h₁ : -R < x - y
h₂ : x - y < R
⊢ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R
case h.mp.intro.inr.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : r < -(x - y)
h₁ : -R < x - y
h₂ : x - y < R
⊢ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mp
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
⊢ (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R → x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | . left
constructor <;> linarith | case h.mp.intro.inl.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : r < x - y
h₁ : -R < x - y
h₂ : x - y < R
⊢ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R
case h.mp.intro.inr.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : r < -(x - y)
h₁ : -R < x - y
h₂ : x - y < R
⊢ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R | case h.mp.intro.inr.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : r < -(x - y)
h₁ : -R < x - y
h₂ : x - y < R
⊢ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mp.intro.inl.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : r < x - y
h₁ : -R < x - y
h₂ : x - y < R
⊢ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R
case h.mp.intro.inr.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : r < -(x - y)
h₁ : -R < x - y
h₂ : x - y < R
⊢ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | . right
constructor <;> linarith | case h.mp.intro.inr.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : r < -(x - y)
h₁ : -R < x - y
h₂ : x - y < R
⊢ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mp.intro.inr.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : r < -(x - y)
h₁ : -R < x - y
h₂ : x - y < R
⊢ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | left | case h.mp.intro.inl.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : r < x - y
h₁ : -R < x - y
h₂ : x - y < R
⊢ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R | case h.mp.intro.inl.intro.h
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : r < x - y
h₁ : -R < x - y
h₂ : x - y < R
⊢ x - R < y ∧ y < x - r | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mp.intro.inl.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : r < x - y
h₁ : -R < x - y
h₂ : x - y < R
⊢ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | constructor <;> linarith | case h.mp.intro.inl.intro.h
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : r < x - y
h₁ : -R < x - y
h₂ : x - y < R
⊢ x - R < y ∧ y < x - r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mp.intro.inl.intro.h
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : r < x - y
h₁ : -R < x - y
h₂ : x - y < R
⊢ x - R < y ∧ y < x - r
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | right | case h.mp.intro.inr.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : r < -(x - y)
h₁ : -R < x - y
h₂ : x - y < R
⊢ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R | case h.mp.intro.inr.intro.h
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : r < -(x - y)
h₁ : -R < x - y
h₂ : x - y < R
⊢ x + r < y ∧ y < x + R | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mp.intro.inr.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : r < -(x - y)
h₁ : -R < x - y
h₂ : x - y < R
⊢ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | constructor <;> linarith | case h.mp.intro.inr.intro.h
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : r < -(x - y)
h₁ : -R < x - y
h₂ : x - y < R
⊢ x + r < y ∧ y < x + R | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mp.intro.inr.intro.h
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : r < -(x - y)
h₁ : -R < x - y
h₂ : x - y < R
⊢ x + r < y ∧ y < x + R
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | rintro (⟨h₀, h₁⟩ | ⟨h₀, h₁⟩) | case h.mpr
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
⊢ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R → (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R | case h.mpr.inl.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x - R < y
h₁ : y < x - r
⊢ (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R
case h.mpr.inr.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x + r < y
h₁ : y < x + R
⊢ (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
⊢ x - R < y ∧ y < x - r ∨ x + r < y ∧ y < x + R → (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | . constructor
. left
linarith
. constructor <;> linarith | case h.mpr.inl.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x - R < y
h₁ : y < x - r
⊢ (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R
case h.mpr.inr.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x + r < y
h₁ : y < x + R
⊢ (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R | case h.mpr.inr.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x + r < y
h₁ : y < x + R
⊢ (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr.inl.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x - R < y
h₁ : y < x - r
⊢ (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R
case h.mpr.inr.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x + r < y
h₁ : y < x + R
⊢ (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | . constructor
. right
linarith
. constructor <;> linarith | case h.mpr.inr.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x + r < y
h₁ : y < x + R
⊢ (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr.inr.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x + r < y
h₁ : y < x + R
⊢ (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | constructor | case h.mpr.inl.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x - R < y
h₁ : y < x - r
⊢ (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R | case h.mpr.inl.intro.left
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x - R < y
h₁ : y < x - r
⊢ r < x - y ∨ r < -(x - y)
case h.mpr.inl.intro.right
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x - R < y
h₁ : y < x - r
⊢ -R < x - y ∧ x - y < R | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr.inl.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x - R < y
h₁ : y < x - r
⊢ (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | . left
linarith | case h.mpr.inl.intro.left
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x - R < y
h₁ : y < x - r
⊢ r < x - y ∨ r < -(x - y)
case h.mpr.inl.intro.right
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x - R < y
h₁ : y < x - r
⊢ -R < x - y ∧ x - y < R | case h.mpr.inl.intro.right
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x - R < y
h₁ : y < x - r
⊢ -R < x - y ∧ x - y < R | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr.inl.intro.left
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x - R < y
h₁ : y < x - r
⊢ r < x - y ∨ r < -(x - y)
case h.mpr.inl.intro.right
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x - R < y
h₁ : y < x - r
⊢ -R < x - y ∧ x - y < R
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | . constructor <;> linarith | case h.mpr.inl.intro.right
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x - R < y
h₁ : y < x - r
⊢ -R < x - y ∧ x - y < R | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr.inl.intro.right
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x - R < y
h₁ : y < x - r
⊢ -R < x - y ∧ x - y < R
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | left | case h.mpr.inl.intro.left
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x - R < y
h₁ : y < x - r
⊢ r < x - y ∨ r < -(x - y) | case h.mpr.inl.intro.left.h
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x - R < y
h₁ : y < x - r
⊢ r < x - y | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr.inl.intro.left
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x - R < y
h₁ : y < x - r
⊢ r < x - y ∨ r < -(x - y)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | linarith | case h.mpr.inl.intro.left.h
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x - R < y
h₁ : y < x - r
⊢ r < x - y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr.inl.intro.left.h
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x - R < y
h₁ : y < x - r
⊢ r < x - y
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | constructor <;> linarith | case h.mpr.inl.intro.right
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x - R < y
h₁ : y < x - r
⊢ -R < x - y ∧ x - y < R | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr.inl.intro.right
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x - R < y
h₁ : y < x - r
⊢ -R < x - y ∧ x - y < R
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | constructor | case h.mpr.inr.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x + r < y
h₁ : y < x + R
⊢ (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R | case h.mpr.inr.intro.left
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x + r < y
h₁ : y < x + R
⊢ r < x - y ∨ r < -(x - y)
case h.mpr.inr.intro.right
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x + r < y
h₁ : y < x + R
⊢ -R < x - y ∧ x - y < R | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr.inr.intro
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x + r < y
h₁ : y < x + R
⊢ (r < x - y ∨ r < -(x - y)) ∧ -R < x - y ∧ x - y < R
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | . right
linarith | case h.mpr.inr.intro.left
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x + r < y
h₁ : y < x + R
⊢ r < x - y ∨ r < -(x - y)
case h.mpr.inr.intro.right
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x + r < y
h₁ : y < x + R
⊢ -R < x - y ∧ x - y < R | case h.mpr.inr.intro.right
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x + r < y
h₁ : y < x + R
⊢ -R < x - y ∧ x - y < R | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr.inr.intro.left
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x + r < y
h₁ : y < x + R
⊢ r < x - y ∨ r < -(x - y)
case h.mpr.inr.intro.right
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x + r < y
h₁ : y < x + R
⊢ -R < x - y ∧ x - y < R
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | . constructor <;> linarith | case h.mpr.inr.intro.right
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x + r < y
h₁ : y < x + R
⊢ -R < x - y ∧ x - y < R | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr.inr.intro.right
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x + r < y
h₁ : y < x + R
⊢ -R < x - y ∧ x - y < R
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | right | case h.mpr.inr.intro.left
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x + r < y
h₁ : y < x + R
⊢ r < x - y ∨ r < -(x - y) | case h.mpr.inr.intro.left.h
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x + r < y
h₁ : y < x + R
⊢ r < -(x - y) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr.inr.intro.left
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x + r < y
h₁ : y < x + R
⊢ r < x - y ∨ r < -(x - y)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | linarith | case h.mpr.inr.intro.left.h
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x + r < y
h₁ : y < x + R
⊢ r < -(x - y) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr.inr.intro.left.h
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x + r < y
h₁ : y < x + R
⊢ r < -(x - y)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | annulus_real_eq | [26, 1] | [44, 33] | constructor <;> linarith | case h.mpr.inr.intro.right
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x + r < y
h₁ : y < x + R
⊢ -R < x - y ∧ x - y < R | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr.inr.intro.right
x r R : ℝ
r_nonneg : 0 ≤ r
y : ℝ
h₀ : x + r < y
h₁ : y < x + R
⊢ -R < x - y ∧ x - y < R
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorRat'_measurable | [48, 1] | [68, 8] | apply measurable_iSup | f : ℝ → ℂ
hf : Measurable f
⊢ Measurable (CarlesonOperatorRat' K f) | case hf
f : ℝ → ℂ
hf : Measurable f
⊢ ∀ (i : ℤ),
Measurable fun b =>
⨆ r, ⨆ (_ : 0 < r), ↑‖∫ (y : ℝ) in {y | dist b y ∈ Set.Ioo (↑r) 1}, f y * K b y * (Complex.I * ↑i * ↑y).exp‖₊ | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℝ → ℂ
hf : Measurable f
⊢ Measurable (CarlesonOperatorRat' K f)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorRat'_measurable | [48, 1] | [68, 8] | intro n | case hf
f : ℝ → ℂ
hf : Measurable f
⊢ ∀ (i : ℤ),
Measurable fun b =>
⨆ r, ⨆ (_ : 0 < r), ↑‖∫ (y : ℝ) in {y | dist b y ∈ Set.Ioo (↑r) 1}, f y * K b y * (Complex.I * ↑i * ↑y).exp‖₊ | case hf
f : ℝ → ℂ
hf : Measurable f
n : ℤ
⊢ Measurable fun b =>
⨆ r, ⨆ (_ : 0 < r), ↑‖∫ (y : ℝ) in {y | dist b y ∈ Set.Ioo (↑r) 1}, f y * K b y * (Complex.I * ↑n * ↑y).exp‖₊ | Please generate a tactic in lean4 to solve the state.
STATE:
case hf
f : ℝ → ℂ
hf : Measurable f
⊢ ∀ (i : ℤ),
Measurable fun b =>
⨆ r, ⨆ (_ : 0 < r), ↑‖∫ (y : ℝ) in {y | dist b y ∈ Set.Ioo (↑r) 1}, f y * K b y * (Complex.I * ↑i * ↑y).exp‖₊
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorRat'_measurable | [48, 1] | [68, 8] | apply measurable_iSup | case hf
f : ℝ → ℂ
hf : Measurable f
n : ℤ
⊢ Measurable fun b =>
⨆ r, ⨆ (_ : 0 < r), ↑‖∫ (y : ℝ) in {y | dist b y ∈ Set.Ioo (↑r) 1}, f y * K b y * (Complex.I * ↑n * ↑y).exp‖₊ | case hf.hf
f : ℝ → ℂ
hf : Measurable f
n : ℤ
⊢ ∀ (i : ℚ),
Measurable fun b =>
⨆ (_ : 0 < i), ↑‖∫ (y : ℝ) in {y | dist b y ∈ Set.Ioo (↑i) 1}, f y * K b y * (Complex.I * ↑n * ↑y).exp‖₊ | Please generate a tactic in lean4 to solve the state.
STATE:
case hf
f : ℝ → ℂ
hf : Measurable f
n : ℤ
⊢ Measurable fun b =>
⨆ r, ⨆ (_ : 0 < r), ↑‖∫ (y : ℝ) in {y | dist b y ∈ Set.Ioo (↑r) 1}, f y * K b y * (Complex.I * ↑n * ↑y).exp‖₊
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorRat'_measurable | [48, 1] | [68, 8] | intro r | case hf.hf
f : ℝ → ℂ
hf : Measurable f
n : ℤ
⊢ ∀ (i : ℚ),
Measurable fun b =>
⨆ (_ : 0 < i), ↑‖∫ (y : ℝ) in {y | dist b y ∈ Set.Ioo (↑i) 1}, f y * K b y * (Complex.I * ↑n * ↑y).exp‖₊ | case hf.hf
f : ℝ → ℂ
hf : Measurable f
n : ℤ
r : ℚ
⊢ Measurable fun b =>
⨆ (_ : 0 < r), ↑‖∫ (y : ℝ) in {y | dist b y ∈ Set.Ioo (↑r) 1}, f y * K b y * (Complex.I * ↑n * ↑y).exp‖₊ | Please generate a tactic in lean4 to solve the state.
STATE:
case hf.hf
f : ℝ → ℂ
hf : Measurable f
n : ℤ
⊢ ∀ (i : ℚ),
Measurable fun b =>
⨆ (_ : 0 < i), ↑‖∫ (y : ℝ) in {y | dist b y ∈ Set.Ioo (↑i) 1}, f y * K b y * (Complex.I * ↑n * ↑y).exp‖₊
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorRat'_measurable | [48, 1] | [68, 8] | apply measurable_iSup | case hf.hf
f : ℝ → ℂ
hf : Measurable f
n : ℤ
r : ℚ
⊢ Measurable fun b =>
⨆ (_ : 0 < r), ↑‖∫ (y : ℝ) in {y | dist b y ∈ Set.Ioo (↑r) 1}, f y * K b y * (Complex.I * ↑n * ↑y).exp‖₊ | case hf.hf.hf
f : ℝ → ℂ
hf : Measurable f
n : ℤ
r : ℚ
⊢ 0 < r → Measurable fun b => ↑‖∫ (y : ℝ) in {y | dist b y ∈ Set.Ioo (↑r) 1}, f y * K b y * (Complex.I * ↑n * ↑y).exp‖₊ | Please generate a tactic in lean4 to solve the state.
STATE:
case hf.hf
f : ℝ → ℂ
hf : Measurable f
n : ℤ
r : ℚ
⊢ Measurable fun b =>
⨆ (_ : 0 < r), ↑‖∫ (y : ℝ) in {y | dist b y ∈ Set.Ioo (↑r) 1}, f y * K b y * (Complex.I * ↑n * ↑y).exp‖₊
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorRat'_measurable | [48, 1] | [68, 8] | intro hr | case hf.hf.hf
f : ℝ → ℂ
hf : Measurable f
n : ℤ
r : ℚ
⊢ 0 < r → Measurable fun b => ↑‖∫ (y : ℝ) in {y | dist b y ∈ Set.Ioo (↑r) 1}, f y * K b y * (Complex.I * ↑n * ↑y).exp‖₊ | case hf.hf.hf
f : ℝ → ℂ
hf : Measurable f
n : ℤ
r : ℚ
hr : 0 < r
⊢ Measurable fun b => ↑‖∫ (y : ℝ) in {y | dist b y ∈ Set.Ioo (↑r) 1}, f y * K b y * (Complex.I * ↑n * ↑y).exp‖₊ | Please generate a tactic in lean4 to solve the state.
STATE:
case hf.hf.hf
f : ℝ → ℂ
hf : Measurable f
n : ℤ
r : ℚ
⊢ 0 < r → Measurable fun b => ↑‖∫ (y : ℝ) in {y | dist b y ∈ Set.Ioo (↑r) 1}, f y * K b y * (Complex.I * ↑n * ↑y).exp‖₊
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorRat'_measurable | [48, 1] | [68, 8] | apply Measurable.coe_nnreal_ennreal | case hf.hf.hf
f : ℝ → ℂ
hf : Measurable f
n : ℤ
r : ℚ
hr : 0 < r
⊢ Measurable fun b => ↑‖∫ (y : ℝ) in {y | dist b y ∈ Set.Ioo (↑r) 1}, f y * K b y * (Complex.I * ↑n * ↑y).exp‖₊ | case hf.hf.hf.hf
f : ℝ → ℂ
hf : Measurable f
n : ℤ
r : ℚ
hr : 0 < r
⊢ Measurable fun x => ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo (↑r) 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ | Please generate a tactic in lean4 to solve the state.
STATE:
case hf.hf.hf
f : ℝ → ℂ
hf : Measurable f
n : ℤ
r : ℚ
hr : 0 < r
⊢ Measurable fun b => ↑‖∫ (y : ℝ) in {y | dist b y ∈ Set.Ioo (↑r) 1}, f y * K b y * (Complex.I * ↑n * ↑y).exp‖₊
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorRat'_measurable | [48, 1] | [68, 8] | apply Measurable.nnnorm | case hf.hf.hf.hf
f : ℝ → ℂ
hf : Measurable f
n : ℤ
r : ℚ
hr : 0 < r
⊢ Measurable fun x => ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo (↑r) 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ | case hf.hf.hf.hf.hf
f : ℝ → ℂ
hf : Measurable f
n : ℤ
r : ℚ
hr : 0 < r
⊢ Measurable fun a => ∫ (y : ℝ) in {y | dist a y ∈ Set.Ioo (↑r) 1}, f y * K a y * (Complex.I * ↑n * ↑y).exp | Please generate a tactic in lean4 to solve the state.
STATE:
case hf.hf.hf.hf
f : ℝ → ℂ
hf : Measurable f
n : ℤ
r : ℚ
hr : 0 < r
⊢ Measurable fun x => ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo (↑r) 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorRat'_measurable | [48, 1] | [68, 8] | sorry | case hf.hf.hf.hf.hf
f : ℝ → ℂ
hf : Measurable f
n : ℤ
r : ℚ
hr : 0 < r
⊢ Measurable fun a => ∫ (y : ℝ) in {y | dist a y ∈ Set.Ioo (↑r) 1}, f y * K a y * (Complex.I * ↑n * ↑y).exp | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case hf.hf.hf.hf.hf
f : ℝ → ℂ
hf : Measurable f
n : ℤ
r : ℚ
hr : 0 < r
⊢ Measurable fun a => ∫ (y : ℝ) in {y | dist a y ∈ Set.Ioo (↑r) 1}, f y * K a y * (Complex.I * ↑n * ↑y).exp
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorReal'_measurable | [72, 1] | [74, 8] | sorry | f : ℝ → ℂ
hf : Measurable f
⊢ Measurable (T' f) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℝ → ℂ
hf : Measurable f
⊢ Measurable (T' f)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorReal'_mul | [76, 1] | [101, 19] | rw [CarlesonOperatorReal', CarlesonOperatorReal', ENNReal.mul_iSup] | f : ℝ → ℂ
x a : ℝ
ha : 0 < a
⊢ T' f x = ↑a.toNNReal * T' (fun x => 1 / ↑a * f x) x | f : ℝ → ℂ
x a : ℝ
ha : 0 < a
⊢ ⨆ n,
⨆ r,
⨆ (_ : 0 < r),
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
⨆ i,
↑a.toNNReal *
⨆ r,
⨆ (_ : 0 < r),
⨆ (_ : r < 1),
↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑i * ↑y).exp‖₊ | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
⊢ T' f x = ↑a.toNNReal * T' (fun x => 1 / ↑a * f x) x
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorReal'_mul | [76, 1] | [101, 19] | congr | f : ℝ → ℂ
x a : ℝ
ha : 0 < a
⊢ ⨆ n,
⨆ r,
⨆ (_ : 0 < r),
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
⨆ i,
↑a.toNNReal *
⨆ r,
⨆ (_ : 0 < r),
⨆ (_ : r < 1),
↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑i * ↑y).exp‖₊ | case e_s
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
⊢ (fun n =>
⨆ r,
⨆ (_ : 0 < r),
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊) =
fun i =>
↑a.toNNReal *
⨆ r,
⨆ (_ : 0 < r),
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑i * ↑y).exp‖₊ | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
⊢ ⨆ n,
⨆ r,
⨆ (_ : 0 < r),
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
⨆ i,
↑a.toNNReal *
⨆ r,
⨆ (_ : 0 < r),
⨆ (_ : r < 1),
↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑i * ↑y).exp‖₊
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorReal'_mul | [76, 1] | [101, 19] | ext n | case e_s
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
⊢ (fun n =>
⨆ r,
⨆ (_ : 0 < r),
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊) =
fun i =>
↑a.toNNReal *
⨆ r,
⨆ (_ : 0 < r),
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑i * ↑y).exp‖₊ | case e_s.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
⊢ ⨆ r,
⨆ (_ : 0 < r),
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
↑a.toNNReal *
⨆ r,
⨆ (_ : 0 < r),
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ | Please generate a tactic in lean4 to solve the state.
STATE:
case e_s
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
⊢ (fun n =>
⨆ r,
⨆ (_ : 0 < r),
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊) =
fun i =>
↑a.toNNReal *
⨆ r,
⨆ (_ : 0 < r),
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑i * ↑y).exp‖₊
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorReal'_mul | [76, 1] | [101, 19] | rw [ENNReal.mul_iSup] | case e_s.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
⊢ ⨆ r,
⨆ (_ : 0 < r),
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
↑a.toNNReal *
⨆ r,
⨆ (_ : 0 < r),
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ | case e_s.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
⊢ ⨆ r,
⨆ (_ : 0 < r),
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
⨆ i,
↑a.toNNReal *
⨆ (_ : 0 < i),
⨆ (_ : i < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo i 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ | Please generate a tactic in lean4 to solve the state.
STATE:
case e_s.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
⊢ ⨆ r,
⨆ (_ : 0 < r),
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
↑a.toNNReal *
⨆ r,
⨆ (_ : 0 < r),
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorReal'_mul | [76, 1] | [101, 19] | congr | case e_s.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
⊢ ⨆ r,
⨆ (_ : 0 < r),
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
⨆ i,
↑a.toNNReal *
⨆ (_ : 0 < i),
⨆ (_ : i < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo i 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ | case e_s.h.e_s
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
⊢ (fun r =>
⨆ (_ : 0 < r),
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊) =
fun i =>
↑a.toNNReal *
⨆ (_ : 0 < i),
⨆ (_ : i < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo i 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ | Please generate a tactic in lean4 to solve the state.
STATE:
case e_s.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
⊢ ⨆ r,
⨆ (_ : 0 < r),
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
⨆ i,
↑a.toNNReal *
⨆ (_ : 0 < i),
⨆ (_ : i < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo i 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorReal'_mul | [76, 1] | [101, 19] | ext r | case e_s.h.e_s
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
⊢ (fun r =>
⨆ (_ : 0 < r),
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊) =
fun i =>
↑a.toNNReal *
⨆ (_ : 0 < i),
⨆ (_ : i < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo i 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ | case e_s.h.e_s.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
⊢ ⨆ (_ : 0 < r), ⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
↑a.toNNReal *
⨆ (_ : 0 < r),
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ | Please generate a tactic in lean4 to solve the state.
STATE:
case e_s.h.e_s
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
⊢ (fun r =>
⨆ (_ : 0 < r),
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊) =
fun i =>
↑a.toNNReal *
⨆ (_ : 0 < i),
⨆ (_ : i < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo i 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorReal'_mul | [76, 1] | [101, 19] | rw [ENNReal.mul_iSup] | case e_s.h.e_s.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
⊢ ⨆ (_ : 0 < r), ⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
↑a.toNNReal *
⨆ (_ : 0 < r),
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ | case e_s.h.e_s.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
⊢ ⨆ (_ : 0 < r), ⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
⨆ (_ : 0 < r),
↑a.toNNReal *
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ | Please generate a tactic in lean4 to solve the state.
STATE:
case e_s.h.e_s.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
⊢ ⨆ (_ : 0 < r), ⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
↑a.toNNReal *
⨆ (_ : 0 < r),
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorReal'_mul | [76, 1] | [101, 19] | congr | case e_s.h.e_s.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
⊢ ⨆ (_ : 0 < r), ⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
⨆ (_ : 0 < r),
↑a.toNNReal *
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ | case e_s.h.e_s.h.e_s
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
⊢ (fun x_1 => ⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊) =
fun i =>
↑a.toNNReal *
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ | Please generate a tactic in lean4 to solve the state.
STATE:
case e_s.h.e_s.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
⊢ ⨆ (_ : 0 < r), ⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
⨆ (_ : 0 < r),
↑a.toNNReal *
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorReal'_mul | [76, 1] | [101, 19] | ext rpos | case e_s.h.e_s.h.e_s
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
⊢ (fun x_1 => ⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊) =
fun i =>
↑a.toNNReal *
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ | case e_s.h.e_s.h.e_s.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
⊢ ⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
↑a.toNNReal *
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ | Please generate a tactic in lean4 to solve the state.
STATE:
case e_s.h.e_s.h.e_s
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
⊢ (fun x_1 => ⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊) =
fun i =>
↑a.toNNReal *
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorReal'_mul | [76, 1] | [101, 19] | rw [ENNReal.mul_iSup] | case e_s.h.e_s.h.e_s.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
⊢ ⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
↑a.toNNReal *
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ | case e_s.h.e_s.h.e_s.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
⊢ ⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
⨆ (_ : r < 1),
↑a.toNNReal * ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ | Please generate a tactic in lean4 to solve the state.
STATE:
case e_s.h.e_s.h.e_s.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
⊢ ⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
↑a.toNNReal *
⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorReal'_mul | [76, 1] | [101, 19] | congr | case e_s.h.e_s.h.e_s.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
⊢ ⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
⨆ (_ : r < 1),
↑a.toNNReal * ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ | case e_s.h.e_s.h.e_s.h.e_s
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
⊢ (fun x_1 => ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊) = fun i =>
↑a.toNNReal * ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ | Please generate a tactic in lean4 to solve the state.
STATE:
case e_s.h.e_s.h.e_s.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
⊢ ⨆ (_ : r < 1), ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
⨆ (_ : r < 1),
↑a.toNNReal * ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorReal'_mul | [76, 1] | [101, 19] | ext rle1 | case e_s.h.e_s.h.e_s.h.e_s
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
⊢ (fun x_1 => ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊) = fun i =>
↑a.toNNReal * ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ | case e_s.h.e_s.h.e_s.h.e_s.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
↑a.toNNReal * ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ | Please generate a tactic in lean4 to solve the state.
STATE:
case e_s.h.e_s.h.e_s.h.e_s
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
⊢ (fun x_1 => ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊) = fun i =>
↑a.toNNReal * ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorReal'_mul | [76, 1] | [101, 19] | norm_cast | case e_s.h.e_s.h.e_s.h.e_s.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
↑a.toNNReal * ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ | case e_s.h.e_s.h.e_s.h.e_s.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
a.toNNReal * ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, ↑(1 / a) * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ | Please generate a tactic in lean4 to solve the state.
STATE:
case e_s.h.e_s.h.e_s.h.e_s.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
↑a.toNNReal * ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, 1 / ↑a * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorReal'_mul | [76, 1] | [101, 19] | apply NNReal.eq | case e_s.h.e_s.h.e_s.h.e_s.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
a.toNNReal * ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, ↑(1 / a) * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ | case e_s.h.e_s.h.e_s.h.e_s.h.a
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
↑(a.toNNReal * ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, ↑(1 / a) * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊) | Please generate a tactic in lean4 to solve the state.
STATE:
case e_s.h.e_s.h.e_s.h.e_s.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
a.toNNReal * ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, ↑(1 / a) * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorReal'_mul | [76, 1] | [101, 19] | simp only [coe_nnnorm, NNReal.coe_mul] | case e_s.h.e_s.h.e_s.h.e_s.h.a
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
↑(a.toNNReal * ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, ↑(1 / a) * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊) | case e_s.h.e_s.h.e_s.h.e_s.h.a
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖ =
↑a.toNNReal * ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, ↑(1 / a) * f y * K x y * (Complex.I * ↑n * ↑y).exp‖ | Please generate a tactic in lean4 to solve the state.
STATE:
case e_s.h.e_s.h.e_s.h.e_s.h.a
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ↑‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊ =
↑(a.toNNReal * ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, ↑(1 / a) * f y * K x y * (Complex.I * ↑n * ↑y).exp‖₊)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorReal'_mul | [76, 1] | [101, 19] | rw [← Real.norm_of_nonneg (@NNReal.zero_le_coe a.toNNReal), ← Complex.norm_real, ← norm_mul] | case e_s.h.e_s.h.e_s.h.e_s.h.a
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖ =
↑a.toNNReal * ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, ↑(1 / a) * f y * K x y * (Complex.I * ↑n * ↑y).exp‖ | case e_s.h.e_s.h.e_s.h.e_s.h.a
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖ =
‖↑↑a.toNNReal * ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, ↑(1 / a) * f y * K x y * (Complex.I * ↑n * ↑y).exp‖ | Please generate a tactic in lean4 to solve the state.
STATE:
case e_s.h.e_s.h.e_s.h.e_s.h.a
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖ =
↑a.toNNReal * ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, ↑(1 / a) * f y * K x y * (Complex.I * ↑n * ↑y).exp‖
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorReal'_mul | [76, 1] | [101, 19] | congr | case e_s.h.e_s.h.e_s.h.e_s.h.a
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖ =
‖↑↑a.toNNReal * ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, ↑(1 / a) * f y * K x y * (Complex.I * ↑n * ↑y).exp‖ | case e_s.h.e_s.h.e_s.h.e_s.h.a.e_a
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp =
↑↑a.toNNReal * ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, ↑(1 / a) * f y * K x y * (Complex.I * ↑n * ↑y).exp | Please generate a tactic in lean4 to solve the state.
STATE:
case e_s.h.e_s.h.e_s.h.e_s.h.a
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ‖∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp‖ =
‖↑↑a.toNNReal * ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, ↑(1 / a) * f y * K x y * (Complex.I * ↑n * ↑y).exp‖
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorReal'_mul | [76, 1] | [101, 19] | rw [← MeasureTheory.integral_mul_left, Real.coe_toNNReal a ha.le] | case e_s.h.e_s.h.e_s.h.e_s.h.a.e_a
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp =
↑↑a.toNNReal * ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, ↑(1 / a) * f y * K x y * (Complex.I * ↑n * ↑y).exp | case e_s.h.e_s.h.e_s.h.e_s.h.a.e_a
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp =
∫ (a_1 : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, ↑a * (↑(1 / a) * f a_1 * K x a_1 * (Complex.I * ↑n * ↑a_1).exp) | Please generate a tactic in lean4 to solve the state.
STATE:
case e_s.h.e_s.h.e_s.h.e_s.h.a.e_a
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp =
↑↑a.toNNReal * ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, ↑(1 / a) * f y * K x y * (Complex.I * ↑n * ↑y).exp
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorReal'_mul | [76, 1] | [101, 19] | congr | case e_s.h.e_s.h.e_s.h.e_s.h.a.e_a
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp =
∫ (a_1 : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, ↑a * (↑(1 / a) * f a_1 * K x a_1 * (Complex.I * ↑n * ↑a_1).exp) | case e_s.h.e_s.h.e_s.h.e_s.h.a.e_a.e_f
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ (fun y => f y * K x y * (Complex.I * ↑n * ↑y).exp) = fun a_1 =>
↑a * (↑(1 / a) * f a_1 * K x a_1 * (Complex.I * ↑n * ↑a_1).exp) | Please generate a tactic in lean4 to solve the state.
STATE:
case e_s.h.e_s.h.e_s.h.e_s.h.a.e_a
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ ∫ (y : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, f y * K x y * (Complex.I * ↑n * ↑y).exp =
∫ (a_1 : ℝ) in {y | dist x y ∈ Set.Ioo r 1}, ↑a * (↑(1 / a) * f a_1 * K x a_1 * (Complex.I * ↑n * ↑a_1).exp)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorReal'_mul | [76, 1] | [101, 19] | ext y | case e_s.h.e_s.h.e_s.h.e_s.h.a.e_a.e_f
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ (fun y => f y * K x y * (Complex.I * ↑n * ↑y).exp) = fun a_1 =>
↑a * (↑(1 / a) * f a_1 * K x a_1 * (Complex.I * ↑n * ↑a_1).exp) | case e_s.h.e_s.h.e_s.h.e_s.h.a.e_a.e_f.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
y : ℝ
⊢ f y * K x y * (Complex.I * ↑n * ↑y).exp = ↑a * (↑(1 / a) * f y * K x y * (Complex.I * ↑n * ↑y).exp) | Please generate a tactic in lean4 to solve the state.
STATE:
case e_s.h.e_s.h.e_s.h.e_s.h.a.e_a.e_f
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
⊢ (fun y => f y * K x y * (Complex.I * ↑n * ↑y).exp) = fun a_1 =>
↑a * (↑(1 / a) * f a_1 * K x a_1 * (Complex.I * ↑n * ↑a_1).exp)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorReal'_mul | [76, 1] | [101, 19] | field_simp | case e_s.h.e_s.h.e_s.h.e_s.h.a.e_a.e_f.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
y : ℝ
⊢ f y * K x y * (Complex.I * ↑n * ↑y).exp = ↑a * (↑(1 / a) * f y * K x y * (Complex.I * ↑n * ↑y).exp) | case e_s.h.e_s.h.e_s.h.e_s.h.a.e_a.e_f.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
y : ℝ
⊢ f y * K x y * (Complex.I * ↑n * ↑y).exp = ↑a * (f y * K x y * (Complex.I * ↑n * ↑y).exp) / ↑a | Please generate a tactic in lean4 to solve the state.
STATE:
case e_s.h.e_s.h.e_s.h.e_s.h.a.e_a.e_f.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
y : ℝ
⊢ f y * K x y * (Complex.I * ↑n * ↑y).exp = ↑a * (↑(1 / a) * f y * K x y * (Complex.I * ↑n * ↑y).exp)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorReal'_mul | [76, 1] | [101, 19] | rw [mul_div_cancel_left₀] | case e_s.h.e_s.h.e_s.h.e_s.h.a.e_a.e_f.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
y : ℝ
⊢ f y * K x y * (Complex.I * ↑n * ↑y).exp = ↑a * (f y * K x y * (Complex.I * ↑n * ↑y).exp) / ↑a | case e_s.h.e_s.h.e_s.h.e_s.h.a.e_a.e_f.h.ha
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
y : ℝ
⊢ ↑a ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case e_s.h.e_s.h.e_s.h.e_s.h.a.e_a.e_f.h
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
y : ℝ
⊢ f y * K x y * (Complex.I * ↑n * ↑y).exp = ↑a * (f y * K x y * (Complex.I * ↑n * ↑y).exp) / ↑a
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorReal'_mul | [76, 1] | [101, 19] | norm_cast | case e_s.h.e_s.h.e_s.h.e_s.h.a.e_a.e_f.h.ha
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
y : ℝ
⊢ ↑a ≠ 0 | case e_s.h.e_s.h.e_s.h.e_s.h.a.e_a.e_f.h.ha
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
y : ℝ
⊢ ¬a = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case e_s.h.e_s.h.e_s.h.e_s.h.a.e_a.e_f.h.ha
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
y : ℝ
⊢ ↑a ≠ 0
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/CarlesonOperatorReal.lean | CarlesonOperatorReal'_mul | [76, 1] | [101, 19] | exact ha.ne.symm | case e_s.h.e_s.h.e_s.h.e_s.h.a.e_a.e_f.h.ha
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
y : ℝ
⊢ ¬a = 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case e_s.h.e_s.h.e_s.h.e_s.h.a.e_a.e_f.h.ha
f : ℝ → ℂ
x a : ℝ
ha : 0 < a
n : ℤ
r : ℝ
rpos : 0 < r
rle1 : r < 1
y : ℝ
⊢ ¬a = 0
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Carleson_on_the_real_line.lean | h1 | [50, 1] | [50, 44] | simp | ⊢ 2 ∈ Set.Ioc 1 2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
⊢ 2 ∈ Set.Ioc 1 2
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Carleson_on_the_real_line.lean | h2 | [51, 1] | [51, 99] | rw [Real.isConjExponent_iff_eq_conjExponent] <;> norm_num | ⊢ Real.IsConjExponent 2 2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
⊢ Real.IsConjExponent 2 2
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Carleson_on_the_real_line.lean | localOscillation_on_emptyset | [53, 1] | [54, 26] | simp [localOscillation] | X : Type
inst✝ : PseudoMetricSpace X
f g : C(X, ℂ)
⊢ localOscillation ∅ f g = 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type
inst✝ : PseudoMetricSpace X
f g : C(X, ℂ)
⊢ localOscillation ∅ f g = 0
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Carleson_on_the_real_line.lean | localOscillation_on_empty_ball | [56, 1] | [59, 42] | convert localOscillation_on_emptyset | X : Type
inst✝ : PseudoMetricSpace X
x : X
f g : C(X, ℂ)
R : ℝ
R_nonpos : R ≤ 0
⊢ localOscillation (Metric.ball x R) f g = 0 | case h.e'_2.h.e'_3
X : Type
inst✝ : PseudoMetricSpace X
x : X
f g : C(X, ℂ)
R : ℝ
R_nonpos : R ≤ 0
⊢ Metric.ball x R = ∅ | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type
inst✝ : PseudoMetricSpace X
x : X
f g : C(X, ℂ)
R : ℝ
R_nonpos : R ≤ 0
⊢ localOscillation (Metric.ball x R) f g = 0
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Carleson_on_the_real_line.lean | localOscillation_on_empty_ball | [56, 1] | [59, 42] | exact Metric.ball_eq_empty.mpr R_nonpos | case h.e'_2.h.e'_3
X : Type
inst✝ : PseudoMetricSpace X
x : X
f g : C(X, ℂ)
R : ℝ
R_nonpos : R ≤ 0
⊢ Metric.ball x R = ∅ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_2.h.e'_3
X : Type
inst✝ : PseudoMetricSpace X
x : X
f g : C(X, ℂ)
R : ℝ
R_nonpos : R ≤ 0
⊢ Metric.ball x R = ∅
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Carleson_on_the_real_line.lean | ConditionallyCompleteLattice.le_biSup | [61, 1] | [104, 22] | apply ConditionallyCompleteLattice.le_csSup | α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
ha : ∃ i ∈ s, f i = a
⊢ a ≤ ⨆ i ∈ s, f i | case a
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
ha : ∃ i ∈ s, f i = a
⊢ BddAbove (Set.range fun i => ⨆ (_ : i ∈ s), f i)
case a
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
ha : ∃ i ∈ s, f i = a
⊢ a ∈ Set.range fun i => ⨆ (_ : i ∈ s), f i | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
ha : ∃ i ∈ s, f i = a
⊢ a ≤ ⨆ i ∈ s, f i
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Carleson_on_the_real_line.lean | ConditionallyCompleteLattice.le_biSup | [61, 1] | [104, 22] | . rw [bddAbove_def] at *
rcases hfs with ⟨x, hx⟩
use (max x (sSup ∅))
intro y hy
simp at hy
rcases hy with ⟨z, hz⟩
rw [iSup] at hz
by_cases h : z ∈ s
. have : (@Set.range α (z ∈ s) fun _ ↦ f z) = {f z} := by
rw [Set.eq_singleton_iff_unique_mem]
constructor
. simpa
. intro x hx
simp at hx
exact hx.2.symm
rw [this] at hz
have : sSup {f z} = f z := by apply csSup_singleton
rw [this] at hz
simp at hx
have : f z ≤ x := hx z h
rw [hz] at this
apply le_max_of_le_left this
have : (@Set.range α (z ∈ s) fun _ ↦ f z) = ∅ := by
simpa
rw [this] at hz
rw [hz]
exact le_max_right x y | case a
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
ha : ∃ i ∈ s, f i = a
⊢ BddAbove (Set.range fun i => ⨆ (_ : i ∈ s), f i)
case a
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
ha : ∃ i ∈ s, f i = a
⊢ a ∈ Set.range fun i => ⨆ (_ : i ∈ s), f i | case a
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
ha : ∃ i ∈ s, f i = a
⊢ a ∈ Set.range fun i => ⨆ (_ : i ∈ s), f i | Please generate a tactic in lean4 to solve the state.
STATE:
case a
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
ha : ∃ i ∈ s, f i = a
⊢ BddAbove (Set.range fun i => ⨆ (_ : i ∈ s), f i)
case a
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
ha : ∃ i ∈ s, f i = a
⊢ a ∈ Set.range fun i => ⨆ (_ : i ∈ s), f i
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Carleson_on_the_real_line.lean | ConditionallyCompleteLattice.le_biSup | [61, 1] | [104, 22] | rw [Set.mem_range] | case a
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
ha : ∃ i ∈ s, f i = a
⊢ a ∈ Set.range fun i => ⨆ (_ : i ∈ s), f i | case a
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
ha : ∃ i ∈ s, f i = a
⊢ ∃ y, ⨆ (_ : y ∈ s), f y = a | Please generate a tactic in lean4 to solve the state.
STATE:
case a
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
ha : ∃ i ∈ s, f i = a
⊢ a ∈ Set.range fun i => ⨆ (_ : i ∈ s), f i
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Carleson_on_the_real_line.lean | ConditionallyCompleteLattice.le_biSup | [61, 1] | [104, 22] | rcases ha with ⟨i, hi, fia⟩ | case a
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
ha : ∃ i ∈ s, f i = a
⊢ ∃ y, ⨆ (_ : y ∈ s), f y = a | case a.intro.intro
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
i : ι
hi : i ∈ s
fia : f i = a
⊢ ∃ y, ⨆ (_ : y ∈ s), f y = a | Please generate a tactic in lean4 to solve the state.
STATE:
case a
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
ha : ∃ i ∈ s, f i = a
⊢ ∃ y, ⨆ (_ : y ∈ s), f y = a
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Carleson_on_the_real_line.lean | ConditionallyCompleteLattice.le_biSup | [61, 1] | [104, 22] | use i | case a.intro.intro
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
i : ι
hi : i ∈ s
fia : f i = a
⊢ ∃ y, ⨆ (_ : y ∈ s), f y = a | case h
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
i : ι
hi : i ∈ s
fia : f i = a
⊢ ⨆ (_ : i ∈ s), f i = a | Please generate a tactic in lean4 to solve the state.
STATE:
case a.intro.intro
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
i : ι
hi : i ∈ s
fia : f i = a
⊢ ∃ y, ⨆ (_ : y ∈ s), f y = a
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Carleson_on_the_real_line.lean | ConditionallyCompleteLattice.le_biSup | [61, 1] | [104, 22] | rw [iSup] | case h
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
i : ι
hi : i ∈ s
fia : f i = a
⊢ ⨆ (_ : i ∈ s), f i = a | case h
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
i : ι
hi : i ∈ s
fia : f i = a
⊢ sSup (Set.range fun h => f i) = a | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
i : ι
hi : i ∈ s
fia : f i = a
⊢ ⨆ (_ : i ∈ s), f i = a
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Carleson_on_the_real_line.lean | ConditionallyCompleteLattice.le_biSup | [61, 1] | [104, 22] | convert csSup_singleton _ | case h
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
i : ι
hi : i ∈ s
fia : f i = a
⊢ sSup (Set.range fun h => f i) = a | case h.e'_2.h.e'_3
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
i : ι
hi : i ∈ s
fia : f i = a
⊢ (Set.range fun h => f i) = {a} | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
i : ι
hi : i ∈ s
fia : f i = a
⊢ sSup (Set.range fun h => f i) = a
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Carleson_on_the_real_line.lean | ConditionallyCompleteLattice.le_biSup | [61, 1] | [104, 22] | rw [Set.eq_singleton_iff_unique_mem] | case h.e'_2.h.e'_3
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
i : ι
hi : i ∈ s
fia : f i = a
⊢ (Set.range fun h => f i) = {a} | case h.e'_2.h.e'_3
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
i : ι
hi : i ∈ s
fia : f i = a
⊢ (a ∈ Set.range fun h => f i) ∧ ∀ x ∈ Set.range fun h => f i, x = a | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_2.h.e'_3
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
i : ι
hi : i ∈ s
fia : f i = a
⊢ (Set.range fun h => f i) = {a}
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Carleson_on_the_real_line.lean | ConditionallyCompleteLattice.le_biSup | [61, 1] | [104, 22] | constructor | case h.e'_2.h.e'_3
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
i : ι
hi : i ∈ s
fia : f i = a
⊢ (a ∈ Set.range fun h => f i) ∧ ∀ x ∈ Set.range fun h => f i, x = a | case h.e'_2.h.e'_3.left
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
i : ι
hi : i ∈ s
fia : f i = a
⊢ a ∈ Set.range fun h => f i
case h.e'_2.h.e'_3.right
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
i : ι
hi : i ∈ s
fia : f i = a
⊢ ∀ x ∈ Set.range fun h => f i, x = a | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_2.h.e'_3
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
i : ι
hi : i ∈ s
fia : f i = a
⊢ (a ∈ Set.range fun h => f i) ∧ ∀ x ∈ Set.range fun h => f i, x = a
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Carleson_on_the_real_line.lean | ConditionallyCompleteLattice.le_biSup | [61, 1] | [104, 22] | . simp
use hi, fia | case h.e'_2.h.e'_3.left
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
i : ι
hi : i ∈ s
fia : f i = a
⊢ a ∈ Set.range fun h => f i
case h.e'_2.h.e'_3.right
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
i : ι
hi : i ∈ s
fia : f i = a
⊢ ∀ x ∈ Set.range fun h => f i, x = a | case h.e'_2.h.e'_3.right
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
i : ι
hi : i ∈ s
fia : f i = a
⊢ ∀ x ∈ Set.range fun h => f i, x = a | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_2.h.e'_3.left
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
i : ι
hi : i ∈ s
fia : f i = a
⊢ a ∈ Set.range fun h => f i
case h.e'_2.h.e'_3.right
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
i : ι
hi : i ∈ s
fia : f i = a
⊢ ∀ x ∈ Set.range fun h => f i, x = a
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Carleson_on_the_real_line.lean | ConditionallyCompleteLattice.le_biSup | [61, 1] | [104, 22] | . intro x hx
simp at hx
rwa [hx.2] at fia | case h.e'_2.h.e'_3.right
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
i : ι
hi : i ∈ s
fia : f i = a
⊢ ∀ x ∈ Set.range fun h => f i, x = a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_2.h.e'_3.right
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
i : ι
hi : i ∈ s
fia : f i = a
⊢ ∀ x ∈ Set.range fun h => f i, x = a
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Carleson_on_the_real_line.lean | ConditionallyCompleteLattice.le_biSup | [61, 1] | [104, 22] | rw [bddAbove_def] at * | case a
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
ha : ∃ i ∈ s, f i = a
⊢ BddAbove (Set.range fun i => ⨆ (_ : i ∈ s), f i) | case a
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : ∃ x, ∀ y ∈ f '' s, y ≤ x
ha : ∃ i ∈ s, f i = a
⊢ ∃ x, ∀ y ∈ Set.range fun i => ⨆ (_ : i ∈ s), f i, y ≤ x | Please generate a tactic in lean4 to solve the state.
STATE:
case a
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : BddAbove (f '' s)
ha : ∃ i ∈ s, f i = a
⊢ BddAbove (Set.range fun i => ⨆ (_ : i ∈ s), f i)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Carleson_on_the_real_line.lean | ConditionallyCompleteLattice.le_biSup | [61, 1] | [104, 22] | rcases hfs with ⟨x, hx⟩ | case a
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : ∃ x, ∀ y ∈ f '' s, y ≤ x
ha : ∃ i ∈ s, f i = a
⊢ ∃ x, ∀ y ∈ Set.range fun i => ⨆ (_ : i ∈ s), f i, y ≤ x | case a.intro
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
ha : ∃ i ∈ s, f i = a
x : α
hx : ∀ y ∈ f '' s, y ≤ x
⊢ ∃ x, ∀ y ∈ Set.range fun i => ⨆ (_ : i ∈ s), f i, y ≤ x | Please generate a tactic in lean4 to solve the state.
STATE:
case a
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
hfs : ∃ x, ∀ y ∈ f '' s, y ≤ x
ha : ∃ i ∈ s, f i = a
⊢ ∃ x, ∀ y ∈ Set.range fun i => ⨆ (_ : i ∈ s), f i, y ≤ x
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Carleson_on_the_real_line.lean | ConditionallyCompleteLattice.le_biSup | [61, 1] | [104, 22] | use (max x (sSup ∅)) | case a.intro
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
ha : ∃ i ∈ s, f i = a
x : α
hx : ∀ y ∈ f '' s, y ≤ x
⊢ ∃ x, ∀ y ∈ Set.range fun i => ⨆ (_ : i ∈ s), f i, y ≤ x | case h
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
ha : ∃ i ∈ s, f i = a
x : α
hx : ∀ y ∈ f '' s, y ≤ x
⊢ ∀ y ∈ Set.range fun i => ⨆ (_ : i ∈ s), f i, y ≤ max x (sSup ∅) | Please generate a tactic in lean4 to solve the state.
STATE:
case a.intro
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
ha : ∃ i ∈ s, f i = a
x : α
hx : ∀ y ∈ f '' s, y ≤ x
⊢ ∃ x, ∀ y ∈ Set.range fun i => ⨆ (_ : i ∈ s), f i, y ≤ x
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Carleson_on_the_real_line.lean | ConditionallyCompleteLattice.le_biSup | [61, 1] | [104, 22] | intro y hy | case h
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
ha : ∃ i ∈ s, f i = a
x : α
hx : ∀ y ∈ f '' s, y ≤ x
⊢ ∀ y ∈ Set.range fun i => ⨆ (_ : i ∈ s), f i, y ≤ max x (sSup ∅) | case h
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
ha : ∃ i ∈ s, f i = a
x : α
hx : ∀ y ∈ f '' s, y ≤ x
y : α
hy : y ∈ Set.range fun i => ⨆ (_ : i ∈ s), f i
⊢ y ≤ max x (sSup ∅) | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
ha : ∃ i ∈ s, f i = a
x : α
hx : ∀ y ∈ f '' s, y ≤ x
⊢ ∀ y ∈ Set.range fun i => ⨆ (_ : i ∈ s), f i, y ≤ max x (sSup ∅)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Carleson_on_the_real_line.lean | ConditionallyCompleteLattice.le_biSup | [61, 1] | [104, 22] | simp at hy | case h
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
ha : ∃ i ∈ s, f i = a
x : α
hx : ∀ y ∈ f '' s, y ≤ x
y : α
hy : y ∈ Set.range fun i => ⨆ (_ : i ∈ s), f i
⊢ y ≤ max x (sSup ∅) | case h
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
ha : ∃ i ∈ s, f i = a
x : α
hx : ∀ y ∈ f '' s, y ≤ x
y : α
hy : ∃ y_1, ⨆ (_ : y_1 ∈ s), f y_1 = y
⊢ y ≤ max x (sSup ∅) | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
ha : ∃ i ∈ s, f i = a
x : α
hx : ∀ y ∈ f '' s, y ≤ x
y : α
hy : y ∈ Set.range fun i => ⨆ (_ : i ∈ s), f i
⊢ y ≤ max x (sSup ∅)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Carleson_on_the_real_line.lean | ConditionallyCompleteLattice.le_biSup | [61, 1] | [104, 22] | rcases hy with ⟨z, hz⟩ | case h
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
ha : ∃ i ∈ s, f i = a
x : α
hx : ∀ y ∈ f '' s, y ≤ x
y : α
hy : ∃ y_1, ⨆ (_ : y_1 ∈ s), f y_1 = y
⊢ y ≤ max x (sSup ∅) | case h.intro
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
ha : ∃ i ∈ s, f i = a
x : α
hx : ∀ y ∈ f '' s, y ≤ x
y : α
z : ι
hz : ⨆ (_ : z ∈ s), f z = y
⊢ y ≤ max x (sSup ∅) | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
ha : ∃ i ∈ s, f i = a
x : α
hx : ∀ y ∈ f '' s, y ≤ x
y : α
hy : ∃ y_1, ⨆ (_ : y_1 ∈ s), f y_1 = y
⊢ y ≤ max x (sSup ∅)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Carleson_on_the_real_line.lean | ConditionallyCompleteLattice.le_biSup | [61, 1] | [104, 22] | rw [iSup] at hz | case h.intro
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
ha : ∃ i ∈ s, f i = a
x : α
hx : ∀ y ∈ f '' s, y ≤ x
y : α
z : ι
hz : ⨆ (_ : z ∈ s), f z = y
⊢ y ≤ max x (sSup ∅) | case h.intro
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
ha : ∃ i ∈ s, f i = a
x : α
hx : ∀ y ∈ f '' s, y ≤ x
y : α
z : ι
hz : sSup (Set.range fun h => f z) = y
⊢ y ≤ max x (sSup ∅) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.intro
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
ha : ∃ i ∈ s, f i = a
x : α
hx : ∀ y ∈ f '' s, y ≤ x
y : α
z : ι
hz : ⨆ (_ : z ∈ s), f z = y
⊢ y ≤ max x (sSup ∅)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Carleson_on_the_real_line.lean | ConditionallyCompleteLattice.le_biSup | [61, 1] | [104, 22] | by_cases h : z ∈ s | case h.intro
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
ha : ∃ i ∈ s, f i = a
x : α
hx : ∀ y ∈ f '' s, y ≤ x
y : α
z : ι
hz : sSup (Set.range fun h => f z) = y
⊢ y ≤ max x (sSup ∅) | case pos
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
ha : ∃ i ∈ s, f i = a
x : α
hx : ∀ y ∈ f '' s, y ≤ x
y : α
z : ι
hz : sSup (Set.range fun h => f z) = y
h : z ∈ s
⊢ y ≤ max x (sSup ∅)
case neg
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
ha : ∃ i ∈ s, f i = a
x : α
hx : ∀ y ∈ f '' s, y ≤ x
y : α
z : ι
hz : sSup (Set.range fun h => f z) = y
h : z ∉ s
⊢ y ≤ max x (sSup ∅) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.intro
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
ha : ∃ i ∈ s, f i = a
x : α
hx : ∀ y ∈ f '' s, y ≤ x
y : α
z : ι
hz : sSup (Set.range fun h => f z) = y
⊢ y ≤ max x (sSup ∅)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Carleson_on_the_real_line.lean | ConditionallyCompleteLattice.le_biSup | [61, 1] | [104, 22] | . have : (@Set.range α (z ∈ s) fun _ ↦ f z) = {f z} := by
rw [Set.eq_singleton_iff_unique_mem]
constructor
. simpa
. intro x hx
simp at hx
exact hx.2.symm
rw [this] at hz
have : sSup {f z} = f z := by apply csSup_singleton
rw [this] at hz
simp at hx
have : f z ≤ x := hx z h
rw [hz] at this
apply le_max_of_le_left this | case pos
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
ha : ∃ i ∈ s, f i = a
x : α
hx : ∀ y ∈ f '' s, y ≤ x
y : α
z : ι
hz : sSup (Set.range fun h => f z) = y
h : z ∈ s
⊢ y ≤ max x (sSup ∅)
case neg
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
ha : ∃ i ∈ s, f i = a
x : α
hx : ∀ y ∈ f '' s, y ≤ x
y : α
z : ι
hz : sSup (Set.range fun h => f z) = y
h : z ∉ s
⊢ y ≤ max x (sSup ∅) | case neg
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
ha : ∃ i ∈ s, f i = a
x : α
hx : ∀ y ∈ f '' s, y ≤ x
y : α
z : ι
hz : sSup (Set.range fun h => f z) = y
h : z ∉ s
⊢ y ≤ max x (sSup ∅) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
ha : ∃ i ∈ s, f i = a
x : α
hx : ∀ y ∈ f '' s, y ≤ x
y : α
z : ι
hz : sSup (Set.range fun h => f z) = y
h : z ∈ s
⊢ y ≤ max x (sSup ∅)
case neg
α : Type
inst✝¹ : ConditionallyCompleteLinearOrder α
ι : Type
inst✝ : Nonempty ι
f : ι → α
s : Set ι
a : α
ha : ∃ i ∈ s, f i = a
x : α
hx : ∀ y ∈ f '' s, y ≤ x
y : α
z : ι
hz : sSup (Set.range fun h => f z) = y
h : z ∉ s
⊢ y ≤ max x (sSup ∅)
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.