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/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | intro N hN x hx | case h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
this :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
β’ β N > Nβ, β x β Set.Icc 0 (2 * Real.pi), Complex.abs (f x - partialFourierSum f N x) β€ Ξ΅ | case h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
this :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
β’ Complex.abs (f x - partialFourierSum f N x) β€ Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
case h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
this :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
β’ β N > Nβ, β x β Set.Icc 0 (2 * Real.pi), Complex.abs (f x - partialFourierSum f N x) β€ Ξ΅
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | have := hNβ N hN.le x | case h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
this :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
β’ Complex.abs (f x - partialFourierSum f N x) β€ Ξ΅ | case h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : dist (g βx) ((β n β Icc (-Int.ofNat N) βN, fourierCoeff (βg) n β’ fourier n) βx) < Ξ΅
β’ Complex.abs (f x - partialFourierSum f N x) β€ Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
case h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
this :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
β’ Complex.abs (f x - partialFourierSum f N x) β€ Ξ΅
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | rw [Complex.dist_eq] at this | case h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : dist (g βx) ((β n β Icc (-Int.ofNat N) βN, fourierCoeff (βg) n β’ fourier n) βx) < Ξ΅
β’ Complex.abs (f x - partialFourierSum f N x) β€ Ξ΅ | case h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - (β n β Icc (-Int.ofNat N) βN, fourierCoeff (βg) n β’ fourier n) βx) < Ξ΅
β’ Complex.abs (f x - partialFourierSum f N x) β€ Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
case h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : dist (g βx) ((β n β Icc (-Int.ofNat N) βN, fourierCoeff (βg) n β’ fourier n) βx) < Ξ΅
β’ Complex.abs (f x - partialFourierSum f N x) β€ Ξ΅
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | simp only [ContinuousMap.coe_sum, sum_apply] at this | case h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - (β n β Icc (-Int.ofNat N) βN, fourierCoeff (βg) n β’ fourier n) βx) < Ξ΅
β’ Complex.abs (f x - partialFourierSum f N x) β€ Ξ΅ | case h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ Complex.abs (f x - partialFourierSum f N x) β€ Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
case h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - (β n β Icc (-Int.ofNat N) βN, fourierCoeff (βg) n β’ fourier n) βx) < Ξ΅
β’ Complex.abs (f x - partialFourierSum f N x) β€ Ξ΅
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | convert this.le using 2 | case h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ Complex.abs (f x - partialFourierSum f N x) β€ Ξ΅ | case h.e'_3.h.e'_6
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ f x - partialFourierSum f N x = g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx | Please generate a tactic in lean4 to solve the state.
STATE:
case h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ Complex.abs (f x - partialFourierSum f N x) β€ Ξ΅
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | congr 1 | case h.e'_3.h.e'_6
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ f x - partialFourierSum f N x = g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx | case h.e'_3.h.e'_6.e_a
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ f x = g βx
case h.e'_3.h.e'_6.e_a
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ partialFourierSum f N x = β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_6
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ f x - partialFourierSum f N x = g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | . rw [g_def, ContinuousMap.coe_mk]
by_cases h : x = 2 * Real.pi
. conv => lhs; rw [h, β zero_add (2 * Real.pi), periodicf]
have := AddCircle.coe_add_period (2 * Real.pi) 0
rw [zero_add] at this
rw [h, this, AddCircle.liftIco_coe_apply]
simp [Real.pi_pos]
. have : x β Set.Ico 0 (2 * Real.pi) := by
use hx.1
apply lt_of_le_of_ne hx.2 h
rw [AddCircle.liftIco_coe_apply]
rw [zero_add]
exact this | case h.e'_3.h.e'_6.e_a
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ f x = g βx
case h.e'_3.h.e'_6.e_a
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ partialFourierSum f N x = β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx | case h.e'_3.h.e'_6.e_a
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ partialFourierSum f N x = β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_6.e_a
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ f x = g βx
case h.e'_3.h.e'_6.e_a
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ partialFourierSum f N x = β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | . rw [partialFourierSum]
congr
ext n
rw [fourierCoeff_correspondence]
simp | case h.e'_3.h.e'_6.e_a
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ partialFourierSum f N x = β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_6.e_a
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ partialFourierSum f N x = β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | rw [fact_iff] | f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
β’ Fact (0 < 2 * Real.pi) | f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
β’ 0 < 2 * Real.pi | Please generate a tactic in lean4 to solve the state.
STATE:
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
β’ Fact (0 < 2 * Real.pi)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | exact Real.two_pi_pos | f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
β’ 0 < 2 * Real.pi | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
β’ 0 < 2 * Real.pi
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | linarith [Real.two_pi_pos] | f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
β’ 0 < 0 + 2 * Real.pi | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
β’ 0 < 0 + 2 * Real.pi
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | apply hasSum_fourier_series_of_summable | f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
β’ HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g | case h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
β’ Summable (fourierCoeff βg) | Please generate a tactic in lean4 to solve the state.
STATE:
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
β’ HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | obtain β¨C, hCβ© := fourierCoeffOn_ContDiff_two_bound periodicf fdiff | case h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
β’ Summable (fourierCoeff βg) | case h.intro
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
β’ Summable (fourierCoeff βg) | Please generate a tactic in lean4 to solve the state.
STATE:
case h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
β’ Summable (fourierCoeff βg)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | set maj : β€ β β := fun i β¦ 1 / (i ^ 2) * C with maj_def | case h.intro
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
β’ Summable (fourierCoeff βg) | case h.intro
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
β’ Summable (fourierCoeff βg) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.intro
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
β’ Summable (fourierCoeff βg)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | have summable_maj : Summable maj := by
by_cases Ceq0 : C = 0
. rw [maj_def, Ceq0]
simp only [one_div, mul_zero]
exact summable_zero
. rw [β summable_div_const_iff Ceq0]
convert Real.summable_one_div_int_pow.mpr one_lt_two using 1
rw [maj_def]
ext i
simp only [one_div]
rw [mul_div_cancel_rightβ]
exact Ceq0 | case h.intro
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
β’ Summable (fourierCoeff βg) | case h.intro
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
β’ Summable (fourierCoeff βg) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.intro
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
β’ Summable (fourierCoeff βg)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | rw [summable_congr @fourierCoeff_correspondence, βsummable_norm_iff] | case h.intro
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
β’ Summable (fourierCoeff βg) | case h.intro
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
β’ Summable fun x => βfourierCoeffOn β― f xβ | Please generate a tactic in lean4 to solve the state.
STATE:
case h.intro
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
β’ Summable (fourierCoeff βg)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | apply summable_of_le_on_nonzero _ _ summable_maj | case h.intro
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
β’ Summable fun x => βfourierCoeffOn β― f xβ | f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
β’ 0 β€ fun x => βfourierCoeffOn β― f xβ
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
β’ β (i : β€), i β 0 β βfourierCoeffOn β― f iβ β€ maj i | Please generate a tactic in lean4 to solve the state.
STATE:
case h.intro
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
β’ Summable fun x => βfourierCoeffOn β― f xβ
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | . intro i
simp | f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
β’ 0 β€ fun x => βfourierCoeffOn β― f xβ
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
β’ β (i : β€), i β 0 β βfourierCoeffOn β― f iβ β€ maj i | f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
β’ β (i : β€), i β 0 β βfourierCoeffOn β― f iβ β€ maj i | Please generate a tactic in lean4 to solve the state.
STATE:
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
β’ 0 β€ fun x => βfourierCoeffOn β― f xβ
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
β’ β (i : β€), i β 0 β βfourierCoeffOn β― f iβ β€ maj i
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | . intro i ine0
rw [maj_def, Complex.norm_eq_abs]
field_simp
exact hC i ine0 | f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
β’ β (i : β€), i β 0 β βfourierCoeffOn β― f iβ β€ maj i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
β’ β (i : β€), i β 0 β βfourierCoeffOn β― f iβ β€ maj i
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | by_cases Ceq0 : C = 0 | f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
β’ Summable maj | case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : C = 0
β’ Summable maj
case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
β’ Summable maj | Please generate a tactic in lean4 to solve the state.
STATE:
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
β’ Summable maj
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | . rw [maj_def, Ceq0]
simp only [one_div, mul_zero]
exact summable_zero | case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : C = 0
β’ Summable maj
case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
β’ Summable maj | case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
β’ Summable maj | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : C = 0
β’ Summable maj
case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
β’ Summable maj
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | . rw [β summable_div_const_iff Ceq0]
convert Real.summable_one_div_int_pow.mpr one_lt_two using 1
rw [maj_def]
ext i
simp only [one_div]
rw [mul_div_cancel_rightβ]
exact Ceq0 | case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
β’ Summable maj | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
β’ Summable maj
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | rw [maj_def, Ceq0] | case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : C = 0
β’ Summable maj | case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : C = 0
β’ Summable fun i => 1 / βi ^ 2 * 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : C = 0
β’ Summable maj
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | simp only [one_div, mul_zero] | case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : C = 0
β’ Summable fun i => 1 / βi ^ 2 * 0 | case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : C = 0
β’ Summable fun i => 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : C = 0
β’ Summable fun i => 1 / βi ^ 2 * 0
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | exact summable_zero | case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : C = 0
β’ Summable fun i => 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : C = 0
β’ Summable fun i => 0
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | rw [β summable_div_const_iff Ceq0] | case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
β’ Summable maj | case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
β’ Summable fun i => maj i / C | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
β’ Summable maj
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | convert Real.summable_one_div_int_pow.mpr one_lt_two using 1 | case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
β’ Summable fun i => maj i / C | case h.e'_5
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
β’ (fun i => maj i / C) = fun n => 1 / βn ^ 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
β’ Summable fun i => maj i / C
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | rw [maj_def] | case h.e'_5
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
β’ (fun i => maj i / C) = fun n => 1 / βn ^ 2 | case h.e'_5
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
β’ (fun i => (fun i => 1 / βi ^ 2 * C) i / C) = fun n => 1 / βn ^ 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_5
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
β’ (fun i => maj i / C) = fun n => 1 / βn ^ 2
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | ext i | case h.e'_5
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
β’ (fun i => (fun i => 1 / βi ^ 2 * C) i / C) = fun n => 1 / βn ^ 2 | case h.e'_5.h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
i : β€
β’ (fun i => 1 / βi ^ 2 * C) i / C = 1 / βi ^ 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_5
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
β’ (fun i => (fun i => 1 / βi ^ 2 * C) i / C) = fun n => 1 / βn ^ 2
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | simp only [one_div] | case h.e'_5.h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
i : β€
β’ (fun i => 1 / βi ^ 2 * C) i / C = 1 / βi ^ 2 | case h.e'_5.h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
i : β€
β’ (βi ^ 2)β»ΒΉ * C / C = (βi ^ 2)β»ΒΉ | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_5.h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
i : β€
β’ (fun i => 1 / βi ^ 2 * C) i / C = 1 / βi ^ 2
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | rw [mul_div_cancel_rightβ] | case h.e'_5.h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
i : β€
β’ (βi ^ 2)β»ΒΉ * C / C = (βi ^ 2)β»ΒΉ | case h.e'_5.h.hb
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
i : β€
β’ C β 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_5.h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
i : β€
β’ (βi ^ 2)β»ΒΉ * C / C = (βi ^ 2)β»ΒΉ
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | exact Ceq0 | case h.e'_5.h.hb
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
i : β€
β’ C β 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_5.h.hb
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
Ceq0 : Β¬C = 0
i : β€
β’ C β 0
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | intro i | f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
β’ 0 β€ fun x => βfourierCoeffOn β― f xβ | f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
i : β€
β’ 0 i β€ (fun x => βfourierCoeffOn β― f xβ) i | Please generate a tactic in lean4 to solve the state.
STATE:
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
β’ 0 β€ fun x => βfourierCoeffOn β― f xβ
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | simp | f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
i : β€
β’ 0 i β€ (fun x => βfourierCoeffOn β― f xβ) i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
i : β€
β’ 0 i β€ (fun x => βfourierCoeffOn β― f xβ) i
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | intro i ine0 | f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
β’ β (i : β€), i β 0 β βfourierCoeffOn β― f iβ β€ maj i | f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
i : β€
ine0 : i β 0
β’ βfourierCoeffOn β― f iβ β€ maj i | Please generate a tactic in lean4 to solve the state.
STATE:
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
β’ β (i : β€), i β 0 β βfourierCoeffOn β― f iβ β€ maj i
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | rw [maj_def, Complex.norm_eq_abs] | f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
i : β€
ine0 : i β 0
β’ βfourierCoeffOn β― f iβ β€ maj i | f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
i : β€
ine0 : i β 0
β’ Complex.abs (fourierCoeffOn β― f i) β€ (fun i => 1 / βi ^ 2 * C) i | Please generate a tactic in lean4 to solve the state.
STATE:
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
i : β€
ine0 : i β 0
β’ βfourierCoeffOn β― f iβ β€ maj i
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | field_simp | f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
i : β€
ine0 : i β 0
β’ Complex.abs (fourierCoeffOn β― f i) β€ (fun i => 1 / βi ^ 2 * C) i | f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
i : β€
ine0 : i β 0
β’ Complex.abs (fourierCoeffOn β― f i) β€ C / βi ^ 2 | Please generate a tactic in lean4 to solve the state.
STATE:
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
i : β€
ine0 : i β 0
β’ Complex.abs (fourierCoeffOn β― f i) β€ (fun i => 1 / βi ^ 2 * C) i
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | exact hC i ine0 | f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
i : β€
ine0 : i β 0
β’ Complex.abs (fourierCoeffOn β― f i) β€ C / βi ^ 2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
C : β
hC : β (n : β€), n β 0 β Complex.abs (fourierCoeffOn Real.two_pi_pos f n) β€ C / βn ^ 2
maj : β€ β β := fun i => 1 / βi ^ 2 * C
maj_def : maj = fun i => 1 / βi ^ 2 * C
summable_maj : Summable maj
i : β€
ine0 : i β 0
β’ Complex.abs (fourierCoeffOn β― f i) β€ C / βi ^ 2
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | rw [g_def, ContinuousMap.coe_mk] | case h.e'_3.h.e'_6.e_a
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ f x = g βx | case h.e'_3.h.e'_6.e_a
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ f x = AddCircle.liftIco (2 * Real.pi) 0 f βx | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_6.e_a
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ f x = g βx
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | by_cases h : x = 2 * Real.pi | case h.e'_3.h.e'_6.e_a
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ f x = AddCircle.liftIco (2 * Real.pi) 0 f βx | case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : x = 2 * Real.pi
β’ f x = AddCircle.liftIco (2 * Real.pi) 0 f βx
case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : Β¬x = 2 * Real.pi
β’ f x = AddCircle.liftIco (2 * Real.pi) 0 f βx | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_6.e_a
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ f x = AddCircle.liftIco (2 * Real.pi) 0 f βx
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | . conv => lhs; rw [h, β zero_add (2 * Real.pi), periodicf]
have := AddCircle.coe_add_period (2 * Real.pi) 0
rw [zero_add] at this
rw [h, this, AddCircle.liftIco_coe_apply]
simp [Real.pi_pos] | case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : x = 2 * Real.pi
β’ f x = AddCircle.liftIco (2 * Real.pi) 0 f βx
case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : Β¬x = 2 * Real.pi
β’ f x = AddCircle.liftIco (2 * Real.pi) 0 f βx | case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : Β¬x = 2 * Real.pi
β’ f x = AddCircle.liftIco (2 * Real.pi) 0 f βx | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : x = 2 * Real.pi
β’ f x = AddCircle.liftIco (2 * Real.pi) 0 f βx
case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : Β¬x = 2 * Real.pi
β’ f x = AddCircle.liftIco (2 * Real.pi) 0 f βx
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | . have : x β Set.Ico 0 (2 * Real.pi) := by
use hx.1
apply lt_of_le_of_ne hx.2 h
rw [AddCircle.liftIco_coe_apply]
rw [zero_add]
exact this | case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : Β¬x = 2 * Real.pi
β’ f x = AddCircle.liftIco (2 * Real.pi) 0 f βx | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : Β¬x = 2 * Real.pi
β’ f x = AddCircle.liftIco (2 * Real.pi) 0 f βx
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | conv => lhs; rw [h, β zero_add (2 * Real.pi), periodicf] | case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : x = 2 * Real.pi
β’ f x = AddCircle.liftIco (2 * Real.pi) 0 f βx | case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : x = 2 * Real.pi
β’ f 0 = AddCircle.liftIco (2 * Real.pi) 0 f βx | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : x = 2 * Real.pi
β’ f x = AddCircle.liftIco (2 * Real.pi) 0 f βx
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | have := AddCircle.coe_add_period (2 * Real.pi) 0 | case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : x = 2 * Real.pi
β’ f 0 = AddCircle.liftIco (2 * Real.pi) 0 f βx | case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβΒΉ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
thisβ : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : x = 2 * Real.pi
this : β(0 + 2 * Real.pi) = β0
β’ f 0 = AddCircle.liftIco (2 * Real.pi) 0 f βx | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : x = 2 * Real.pi
β’ f 0 = AddCircle.liftIco (2 * Real.pi) 0 f βx
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | rw [zero_add] at this | case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβΒΉ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
thisβ : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : x = 2 * Real.pi
this : β(0 + 2 * Real.pi) = β0
β’ f 0 = AddCircle.liftIco (2 * Real.pi) 0 f βx | case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβΒΉ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
thisβ : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : x = 2 * Real.pi
this : β(2 * Real.pi) = β0
β’ f 0 = AddCircle.liftIco (2 * Real.pi) 0 f βx | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβΒΉ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
thisβ : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : x = 2 * Real.pi
this : β(0 + 2 * Real.pi) = β0
β’ f 0 = AddCircle.liftIco (2 * Real.pi) 0 f βx
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | rw [h, this, AddCircle.liftIco_coe_apply] | case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβΒΉ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
thisβ : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : x = 2 * Real.pi
this : β(2 * Real.pi) = β0
β’ f 0 = AddCircle.liftIco (2 * Real.pi) 0 f βx | case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβΒΉ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
thisβ : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : x = 2 * Real.pi
this : β(2 * Real.pi) = β0
β’ 0 β Set.Ico 0 (0 + 2 * Real.pi) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβΒΉ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
thisβ : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : x = 2 * Real.pi
this : β(2 * Real.pi) = β0
β’ f 0 = AddCircle.liftIco (2 * Real.pi) 0 f βx
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | simp [Real.pi_pos] | case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβΒΉ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
thisβ : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : x = 2 * Real.pi
this : β(2 * Real.pi) = β0
β’ 0 β Set.Ico 0 (0 + 2 * Real.pi) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβΒΉ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
thisβ : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : x = 2 * Real.pi
this : β(2 * Real.pi) = β0
β’ 0 β Set.Ico 0 (0 + 2 * Real.pi)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | have : x β Set.Ico 0 (2 * Real.pi) := by
use hx.1
apply lt_of_le_of_ne hx.2 h | case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : Β¬x = 2 * Real.pi
β’ f x = AddCircle.liftIco (2 * Real.pi) 0 f βx | case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβΒΉ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
thisβ : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : Β¬x = 2 * Real.pi
this : x β Set.Ico 0 (2 * Real.pi)
β’ f x = AddCircle.liftIco (2 * Real.pi) 0 f βx | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : Β¬x = 2 * Real.pi
β’ f x = AddCircle.liftIco (2 * Real.pi) 0 f βx
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | rw [AddCircle.liftIco_coe_apply] | case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβΒΉ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
thisβ : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : Β¬x = 2 * Real.pi
this : x β Set.Ico 0 (2 * Real.pi)
β’ f x = AddCircle.liftIco (2 * Real.pi) 0 f βx | case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβΒΉ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
thisβ : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : Β¬x = 2 * Real.pi
this : x β Set.Ico 0 (2 * Real.pi)
β’ x β Set.Ico 0 (0 + 2 * Real.pi) | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβΒΉ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
thisβ : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : Β¬x = 2 * Real.pi
this : x β Set.Ico 0 (2 * Real.pi)
β’ f x = AddCircle.liftIco (2 * Real.pi) 0 f βx
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | rw [zero_add] | case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβΒΉ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
thisβ : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : Β¬x = 2 * Real.pi
this : x β Set.Ico 0 (2 * Real.pi)
β’ x β Set.Ico 0 (0 + 2 * Real.pi) | case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβΒΉ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
thisβ : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : Β¬x = 2 * Real.pi
this : x β Set.Ico 0 (2 * Real.pi)
β’ x β Set.Ico 0 (2 * Real.pi) | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβΒΉ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
thisβ : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : Β¬x = 2 * Real.pi
this : x β Set.Ico 0 (2 * Real.pi)
β’ x β Set.Ico 0 (0 + 2 * Real.pi)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | exact this | case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβΒΉ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
thisβ : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : Β¬x = 2 * Real.pi
this : x β Set.Ico 0 (2 * Real.pi)
β’ x β Set.Ico 0 (2 * Real.pi) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβΒΉ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
thisβ : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : Β¬x = 2 * Real.pi
this : x β Set.Ico 0 (2 * Real.pi)
β’ x β Set.Ico 0 (2 * Real.pi)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | use hx.1 | f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : Β¬x = 2 * Real.pi
β’ x β Set.Ico 0 (2 * Real.pi) | case right
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : Β¬x = 2 * Real.pi
β’ x < 2 * Real.pi | Please generate a tactic in lean4 to solve the state.
STATE:
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : Β¬x = 2 * Real.pi
β’ x β Set.Ico 0 (2 * Real.pi)
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | apply lt_of_le_of_ne hx.2 h | case right
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : Β¬x = 2 * Real.pi
β’ x < 2 * Real.pi | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case right
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
h : Β¬x = 2 * Real.pi
β’ x < 2 * Real.pi
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | rw [partialFourierSum] | case h.e'_3.h.e'_6.e_a
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ partialFourierSum f N x = β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx | case h.e'_3.h.e'_6.e_a
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ β n β Icc (-Int.ofNat N) βN, fourierCoeffOn Real.two_pi_pos f n * (fourier n) βx =
β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_6.e_a
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ partialFourierSum f N x = β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | congr | case h.e'_3.h.e'_6.e_a
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ β n β Icc (-Int.ofNat N) βN, fourierCoeffOn Real.two_pi_pos f n * (fourier n) βx =
β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx | case h.e'_3.h.e'_6.e_a.e_f
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ (fun n => fourierCoeffOn Real.two_pi_pos f n * (fourier n) βx) = fun c => (fourierCoeff (βg) c β’ fourier c) βx | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_6.e_a
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ β n β Icc (-Int.ofNat N) βN, fourierCoeffOn Real.two_pi_pos f n * (fourier n) βx =
β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | ext n | case h.e'_3.h.e'_6.e_a.e_f
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ (fun n => fourierCoeffOn Real.two_pi_pos f n * (fourier n) βx) = fun c => (fourierCoeff (βg) c β’ fourier c) βx | case h.e'_3.h.e'_6.e_a.e_f.h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
n : β€
β’ fourierCoeffOn Real.two_pi_pos f n * (fourier n) βx = (fourierCoeff (βg) n β’ fourier n) βx | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_6.e_a.e_f
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
β’ (fun n => fourierCoeffOn Real.two_pi_pos f n * (fourier n) βx) = fun c => (fourierCoeff (βg) c β’ fourier c) βx
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | rw [fourierCoeff_correspondence] | case h.e'_3.h.e'_6.e_a.e_f.h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
n : β€
β’ fourierCoeffOn Real.two_pi_pos f n * (fourier n) βx = (fourierCoeff (βg) n β’ fourier n) βx | case h.e'_3.h.e'_6.e_a.e_f.h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
n : β€
β’ fourierCoeffOn Real.two_pi_pos f n * (fourier n) βx = (fourierCoeffOn β― f n β’ fourier n) βx | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_6.e_a.e_f.h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
n : β€
β’ fourierCoeffOn Real.two_pi_pos f n * (fourier n) βx = (fourierCoeff (βg) n β’ fourier n) βx
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/Theorem1_1/Approximation.lean | fourierConv_ofTwiceDifferentiable | [297, 1] | [362, 9] | simp | case h.e'_3.h.e'_6.e_a.e_f.h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
n : β€
β’ fourierCoeffOn Real.two_pi_pos f n * (fourier n) βx = (fourierCoeffOn β― f n β’ fourier n) βx | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_6.e_a.e_f.h
f : β β β
periodicf : Function.Periodic f (2 * Real.pi)
fdiff : ContDiff β 2 f
Ξ΅ : β
Ξ΅pos : Ξ΅ > 0
fact_two_pi_pos : Fact (0 < 2 * Real.pi)
g : C(AddCircle (2 * Real.pi), β) := { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
g_def : g = { toFun := AddCircle.liftIco (2 * Real.pi) 0 f, continuous_toFun := β― }
two_pi_pos' : 0 < 0 + 2 * Real.pi
fourierCoeff_correspondence : β {i : β€}, fourierCoeff (βg) i = fourierCoeffOn β― f i
function_sum : HasSum (fun i => fourierCoeff (βg) i β’ fourier i) g
thisβ :
β Ξ΅ > 0,
βαΆ (n : β) in atTop,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat n) βn, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
Nβ : β
hNβ :
β b β₯ Nβ,
β (x : AddCircle (2 * Real.pi)), dist (g x) ((β n β Icc (-Int.ofNat b) βb, fourierCoeff (βg) n β’ fourier n) x) < Ξ΅
N : β
hN : N > Nβ
x : β
hx : x β Set.Icc 0 (2 * Real.pi)
this : Complex.abs (g βx - β c β Icc (-Int.ofNat N) βN, (fourierCoeff (βg) c β’ fourier c) βx) < Ξ΅
n : β€
β’ fourierCoeffOn Real.two_pi_pos f n * (fourier n) βx = (fourierCoeffOn β― f n β’ fourier n) βx
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.mono_set | [20, 1] | [23, 41] | induction h | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h : CoveredByBalls t n r
h2 : s β t
β’ CoveredByBalls s n r | case mk
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h2 : s β t
ballsβ : Finset X
card_ballsβ : ballsβ.card β€ n
union_ballsβ : t β β x β ballsβ, ball x r
β’ CoveredByBalls s n r | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h : CoveredByBalls t n r
h2 : s β t
β’ CoveredByBalls s n r
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.mono_set | [20, 1] | [23, 41] | case mk b hn ht =>
exact β¨b, hn, fun x hx β¦ ht (h2 hx)β© | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h2 : s β t
b : Finset X
hn : b.card β€ n
ht : t β β x β b, ball x r
β’ CoveredByBalls s n r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h2 : s β t
b : Finset X
hn : b.card β€ n
ht : t β β x β b, ball x r
β’ CoveredByBalls s n r
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.mono_set | [20, 1] | [23, 41] | exact β¨b, hn, fun x hx β¦ ht (h2 hx)β© | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h2 : s β t
b : Finset X
hn : b.card β€ n
ht : t β β x β b, ball x r
β’ CoveredByBalls s n r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h2 : s β t
b : Finset X
hn : b.card β€ n
ht : t β β x β b, ball x r
β’ CoveredByBalls s n r
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.mono_nat | [25, 1] | [29, 35] | induction h | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h : CoveredByBalls s n r
h2 : n β€ m
β’ CoveredByBalls s m r | case mk
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h2 : n β€ m
ballsβ : Finset X
card_ballsβ : ballsβ.card β€ n
union_ballsβ : s β β x β ballsβ, ball x r
β’ CoveredByBalls s m r | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h : CoveredByBalls s n r
h2 : n β€ m
β’ CoveredByBalls s m r
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.mono_nat | [25, 1] | [29, 35] | case mk b hn hs =>
exact β¨b, hn.trans h2, hsβ© | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h2 : n β€ m
b : Finset X
hn : b.card β€ n
hs : s β β x β b, ball x r
β’ CoveredByBalls s m r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h2 : n β€ m
b : Finset X
hn : b.card β€ n
hs : s β β x β b, ball x r
β’ CoveredByBalls s m r
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.mono_nat | [25, 1] | [29, 35] | exact β¨b, hn.trans h2, hsβ© | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h2 : n β€ m
b : Finset X
hn : b.card β€ n
hs : s β β x β b, ball x r
β’ CoveredByBalls s m r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h2 : n β€ m
b : Finset X
hn : b.card β€ n
hs : s β β x β b, ball x r
β’ CoveredByBalls s m r
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.mono_real | [31, 1] | [35, 44] | induction h | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h : CoveredByBalls s n r
h2 : r β€ r'
β’ CoveredByBalls s n r' | case mk
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h2 : r β€ r'
ballsβ : Finset X
card_ballsβ : ballsβ.card β€ n
union_ballsβ : s β β x β ballsβ, ball x r
β’ CoveredByBalls s n r' | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h : CoveredByBalls s n r
h2 : r β€ r'
β’ CoveredByBalls s n r'
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.mono_real | [31, 1] | [35, 44] | case mk b hn hs =>
exact β¨b, hn, hs.trans (by gcongr)β© | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h2 : r β€ r'
b : Finset X
hn : b.card β€ n
hs : s β β x β b, ball x r
β’ CoveredByBalls s n r' | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h2 : r β€ r'
b : Finset X
hn : b.card β€ n
hs : s β β x β b, ball x r
β’ CoveredByBalls s n r'
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.mono_real | [31, 1] | [35, 44] | exact β¨b, hn, hs.trans (by gcongr)β© | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h2 : r β€ r'
b : Finset X
hn : b.card β€ n
hs : s β β x β b, ball x r
β’ CoveredByBalls s n r' | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h2 : r β€ r'
b : Finset X
hn : b.card β€ n
hs : s β β x β b, ball x r
β’ CoveredByBalls s n r'
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.mono_real | [31, 1] | [35, 44] | gcongr | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h2 : r β€ r'
b : Finset X
hn : b.card β€ n
hs : s β β x β b, ball x r
β’ β x β b, ball x r β β x β b, ball x r' | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h2 : r β€ r'
b : Finset X
hn : b.card β€ n
hs : s β β x β b, ball x r
β’ β x β b, ball x r β β x β b, ball x r'
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.empty | [37, 1] | [39, 24] | simp | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
β’ β
.card β€ n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
β’ β
.card β€ n
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.empty | [37, 1] | [39, 24] | simp | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
β’ β
β β x β β
, ball x r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
β’ β
β β x β β
, ball x r
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.zero_left | [41, 1] | [52, 32] | have h1 : CoveredByBalls s 0 r β s = β
:= by
intro β¨b, hn, hsβ©
simp at hn
subst hn
simp at hs
exact Set.subset_eq_empty hs rfl | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
β’ CoveredByBalls s 0 r β s = β
| X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s 0 r β s = β
β’ CoveredByBalls s 0 r β s = β
| Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
β’ CoveredByBalls s 0 r β s = β
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.zero_left | [41, 1] | [52, 32] | have h2 : s = β
β CoveredByBalls s 0 r := by
rintro rfl
exact CoveredByBalls.empty | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s 0 r β s = β
β’ CoveredByBalls s 0 r β s = β
| X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s 0 r β s = β
h2 : s = β
β CoveredByBalls s 0 r
β’ CoveredByBalls s 0 r β s = β
| Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s 0 r β s = β
β’ CoveredByBalls s 0 r β s = β
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.zero_left | [41, 1] | [52, 32] | exact { mp := h1, mpr := h2 } | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s 0 r β s = β
h2 : s = β
β CoveredByBalls s 0 r
β’ CoveredByBalls s 0 r β s = β
| no goals | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s 0 r β s = β
h2 : s = β
β CoveredByBalls s 0 r
β’ CoveredByBalls s 0 r β s = β
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.zero_left | [41, 1] | [52, 32] | intro β¨b, hn, hsβ© | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
β’ CoveredByBalls s 0 r β s = β
| X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
b : Finset X
hn : b.card β€ 0
hs : s β β x β b, ball x r
β’ s = β
| Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
β’ CoveredByBalls s 0 r β s = β
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.zero_left | [41, 1] | [52, 32] | simp at hn | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
b : Finset X
hn : b.card β€ 0
hs : s β β x β b, ball x r
β’ s = β
| X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
b : Finset X
hs : s β β x β b, ball x r
hn : b = β
β’ s = β
| Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
b : Finset X
hn : b.card β€ 0
hs : s β β x β b, ball x r
β’ s = β
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.zero_left | [41, 1] | [52, 32] | subst hn | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
b : Finset X
hs : s β β x β b, ball x r
hn : b = β
β’ s = β
| X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
hs : s β β x β β
, ball x r
β’ s = β
| Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
b : Finset X
hs : s β β x β b, ball x r
hn : b = β
β’ s = β
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.zero_left | [41, 1] | [52, 32] | simp at hs | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
hs : s β β x β β
, ball x r
β’ s = β
| X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
hs : s β β
β’ s = β
| Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
hs : s β β x β β
, ball x r
β’ s = β
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.zero_left | [41, 1] | [52, 32] | exact Set.subset_eq_empty hs rfl | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
hs : s β β
β’ s = β
| no goals | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
hs : s β β
β’ s = β
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.zero_left | [41, 1] | [52, 32] | rintro rfl | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s 0 r β s = β
β’ s = β
β CoveredByBalls s 0 r | X : Type u_1
instβ : PseudoMetricSpace X
t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls β
0 r β β
= β
β’ CoveredByBalls β
0 r | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s 0 r β s = β
β’ s = β
β CoveredByBalls s 0 r
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.zero_left | [41, 1] | [52, 32] | exact CoveredByBalls.empty | X : Type u_1
instβ : PseudoMetricSpace X
t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls β
0 r β β
= β
β’ CoveredByBalls β
0 r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls β
0 r β β
= β
β’ CoveredByBalls β
0 r
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.zero_right | [56, 1] | [71, 32] | have h1 : CoveredByBalls s n 0 β s =β
:= by
intro hcovered
cases hcovered
case mk b hn hs =>
simp at hs
exact Set.subset_eq_empty hs rfl | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
β’ CoveredByBalls s n 0 β s = β
| X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s n 0 β s = β
β’ CoveredByBalls s n 0 β s = β
| Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
β’ CoveredByBalls s n 0 β s = β
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.zero_right | [56, 1] | [71, 32] | have h2 : s = β
β CoveredByBalls s n 0 := by
intro hs
have h21 : (β
: Finset X).card β€ n := by exact tsub_add_cancel_iff_le.mp rfl
have h22 : s β β x β (β
: Finset X), ball x 0 := by
simp only [not_mem_empty, ball_zero, Set.iUnion_of_empty, Set.iUnion_empty]
exact Set.subset_empty_iff.mpr hs
exact β¨(β
: Finset X), h21, h22β© | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s n 0 β s = β
β’ CoveredByBalls s n 0 β s = β
| X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s n 0 β s = β
h2 : s = β
β CoveredByBalls s n 0
β’ CoveredByBalls s n 0 β s = β
| Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s n 0 β s = β
β’ CoveredByBalls s n 0 β s = β
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.zero_right | [56, 1] | [71, 32] | exact { mp := h1, mpr := h2 } | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s n 0 β s = β
h2 : s = β
β CoveredByBalls s n 0
β’ CoveredByBalls s n 0 β s = β
| no goals | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s n 0 β s = β
h2 : s = β
β CoveredByBalls s n 0
β’ CoveredByBalls s n 0 β s = β
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.zero_right | [56, 1] | [71, 32] | intro hcovered | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
β’ CoveredByBalls s n 0 β s = β
| X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
hcovered : CoveredByBalls s n 0
β’ s = β
| Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
β’ CoveredByBalls s n 0 β s = β
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.zero_right | [56, 1] | [71, 32] | cases hcovered | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
hcovered : CoveredByBalls s n 0
β’ s = β
| case mk
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
ballsβ : Finset X
card_ballsβ : ballsβ.card β€ n
union_ballsβ : s β β x β ballsβ, ball x 0
β’ s = β
| Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
hcovered : CoveredByBalls s n 0
β’ s = β
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.zero_right | [56, 1] | [71, 32] | case mk b hn hs =>
simp at hs
exact Set.subset_eq_empty hs rfl | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
b : Finset X
hn : b.card β€ n
hs : s β β x β b, ball x 0
β’ s = β
| no goals | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
b : Finset X
hn : b.card β€ n
hs : s β β x β b, ball x 0
β’ s = β
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.zero_right | [56, 1] | [71, 32] | simp at hs | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
b : Finset X
hn : b.card β€ n
hs : s β β x β b, ball x 0
β’ s = β
| X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
b : Finset X
hn : b.card β€ n
hs : s β β
β’ s = β
| Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
b : Finset X
hn : b.card β€ n
hs : s β β x β b, ball x 0
β’ s = β
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.zero_right | [56, 1] | [71, 32] | exact Set.subset_eq_empty hs rfl | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
b : Finset X
hn : b.card β€ n
hs : s β β
β’ s = β
| no goals | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
b : Finset X
hn : b.card β€ n
hs : s β β
β’ s = β
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.zero_right | [56, 1] | [71, 32] | intro hs | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s n 0 β s = β
β’ s = β
β CoveredByBalls s n 0 | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s n 0 β s = β
hs : s = β
β’ CoveredByBalls s n 0 | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s n 0 β s = β
β’ s = β
β CoveredByBalls s n 0
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.zero_right | [56, 1] | [71, 32] | have h21 : (β
: Finset X).card β€ n := by exact tsub_add_cancel_iff_le.mp rfl | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s n 0 β s = β
hs : s = β
β’ CoveredByBalls s n 0 | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s n 0 β s = β
hs : s = β
h21 : β
.card β€ n
β’ CoveredByBalls s n 0 | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s n 0 β s = β
hs : s = β
β’ CoveredByBalls s n 0
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.zero_right | [56, 1] | [71, 32] | have h22 : s β β x β (β
: Finset X), ball x 0 := by
simp only [not_mem_empty, ball_zero, Set.iUnion_of_empty, Set.iUnion_empty]
exact Set.subset_empty_iff.mpr hs | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s n 0 β s = β
hs : s = β
h21 : β
.card β€ n
β’ CoveredByBalls s n 0 | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s n 0 β s = β
hs : s = β
h21 : β
.card β€ n
h22 : s β β x β β
, ball x 0
β’ CoveredByBalls s n 0 | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s n 0 β s = β
hs : s = β
h21 : β
.card β€ n
β’ CoveredByBalls s n 0
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.zero_right | [56, 1] | [71, 32] | exact β¨(β
: Finset X), h21, h22β© | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s n 0 β s = β
hs : s = β
h21 : β
.card β€ n
h22 : s β β x β β
, ball x 0
β’ CoveredByBalls s n 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s n 0 β s = β
hs : s = β
h21 : β
.card β€ n
h22 : s β β x β β
, ball x 0
β’ CoveredByBalls s n 0
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.zero_right | [56, 1] | [71, 32] | exact tsub_add_cancel_iff_le.mp rfl | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s n 0 β s = β
hs : s = β
β’ β
.card β€ n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s n 0 β s = β
hs : s = β
β’ β
.card β€ n
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.zero_right | [56, 1] | [71, 32] | simp only [not_mem_empty, ball_zero, Set.iUnion_of_empty, Set.iUnion_empty] | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s n 0 β s = β
hs : s = β
h21 : β
.card β€ n
β’ s β β x β β
, ball x 0 | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s n 0 β s = β
hs : s = β
h21 : β
.card β€ n
β’ s β β
| Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s n 0 β s = β
hs : s = β
h21 : β
.card β€ n
β’ s β β x β β
, ball x 0
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.zero_right | [56, 1] | [71, 32] | exact Set.subset_empty_iff.mpr hs | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s n 0 β s = β
hs : s = β
h21 : β
.card β€ n
β’ s β β
| no goals | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h1 : CoveredByBalls s n 0 β s = β
hs : s = β
h21 : β
.card β€ n
β’ s β β
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.trans | [78, 1] | [82, 10] | cases h | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h : CoveredByBalls s n r
h2 : BallsCoverBalls X r r' m
β’ CoveredByBalls s (n * m) r' | case mk
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h2 : BallsCoverBalls X r r' m
ballsβ : Finset X
card_ballsβ : ballsβ.card β€ n
union_ballsβ : s β β x β ballsβ, ball x r
β’ CoveredByBalls s (n * m) r' | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h : CoveredByBalls s n r
h2 : BallsCoverBalls X r r' m
β’ CoveredByBalls s (n * m) r'
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.trans | [78, 1] | [82, 10] | case mk b0 hb0 hs0 | case mk
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h2 : BallsCoverBalls X r r' m
ballsβ : Finset X
card_ballsβ : ballsβ.card β€ n
union_ballsβ : s β β x β ballsβ, ball x r
β’ CoveredByBalls s (n * m) r' | case mk
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h2 : BallsCoverBalls X r r' m
b0 : Finset X
hb0 : b0.card β€ n
hs0 : s β β x β b0, ball x r
β’ CoveredByBalls s (n * m) r' | Please generate a tactic in lean4 to solve the state.
STATE:
case mk
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h2 : BallsCoverBalls X r r' m
ballsβ : Finset X
card_ballsβ : ballsβ.card β€ n
union_ballsβ : s β β x β ballsβ, ball x r
β’ CoveredByBalls s (n * m) r'
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | CoveredByBalls.trans | [78, 1] | [82, 10] | sorry | case mk
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h2 : BallsCoverBalls X r r' m
b0 : Finset X
hb0 : b0.card β€ n
hs0 : s β β x β b0, ball x r
β’ CoveredByBalls s (n * m) r' | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mk
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
r r' rβ rβ rβ : β
h2 : BallsCoverBalls X r r' m
b0 : Finset X
hb0 : b0.card β€ n
hs0 : s β β x β b0, ball x r
β’ CoveredByBalls s (n * m) r'
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | BallCoversSelf | [90, 1] | [97, 2] | let a : Finset X := singleton x | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
rβ r' rβ rβ rβ : β
x : X
r : β
β’ CoveredByBalls (ball x r) 1 r | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
rβ r' rβ rβ rβ : β
x : X
r : β
a : Finset X := {x}
β’ CoveredByBalls (ball x r) 1 r | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
rβ r' rβ rβ rβ : β
x : X
r : β
β’ CoveredByBalls (ball x r) 1 r
TACTIC:
|
https://github.com/fpvandoorn/carleson.git | 6d448ddfa1ff78506367ab09a8caac5351011ead | Carleson/CoverByBalls.lean | BallCoversSelf | [90, 1] | [97, 2] | have h : a.card β€ 1 := by rfl | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
rβ r' rβ rβ rβ : β
x : X
r : β
a : Finset X := {x}
β’ CoveredByBalls (ball x r) 1 r | X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
rβ r' rβ rβ rβ : β
x : X
r : β
a : Finset X := {x}
h : a.card β€ 1
β’ CoveredByBalls (ball x r) 1 r | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type u_1
instβ : PseudoMetricSpace X
s t : Set X
n m : β
rβ r' rβ rβ rβ : β
x : X
r : β
a : Finset X := {x}
β’ CoveredByBalls (ball x r) 1 r
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.