| import Mathlib |
| import OAI.MeasureTheory.FalconerCompletion.Fourier.StationaryInverseUnit |
|
|
| namespace OAI |
|
|
| /-! Angular cutoffs and derivative estimates. -/ |
|
|
| section |
| section |
| open Set MeasureTheory |
| open scoped ComplexConjugate RealInnerProductSpace |
| namespace GraphLiteralSupport |
| namespace CurrentFalconer |
| open scoped ContDiff |
| variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℝ V] |
|
|
| noncomputable def angularOperatorND (A : V →L[ℝ] V) : Module.End ℂ (SmoothFunctionND V) where |
| toFun b := ⟨angularDerivativeND A b.1,angularDerivativeND_contDiff A b.2⟩ |
| map_add' b c := Subtype.ext (angularDerivativeND_add A b.2 c.2) |
| map_smul' z b := Subtype.ext (angularDerivativeND_const_mul A b.2 z) |
|
|
| lemma smoothFunctionND_contDiff (f : SmoothFunctionND V) : ContDiff ℝ ∞ f.1 := f.2 |
|
|
| noncomputable def smoothMulND (f g : SmoothFunctionND V) : SmoothFunctionND V := |
| ⟨fun x => f.1 x*g.1 x,(smoothFunctionND_contDiff f).mul (smoothFunctionND_contDiff g)⟩ |
|
|
| lemma angularOperatorND_mul (A : V →L[ℝ] V) (f g : SmoothFunctionND V) : |
| angularOperatorND A (smoothMulND f g)= |
| smoothMulND (angularOperatorND A f) g+smoothMulND f (angularOperatorND A g) := by |
| apply Subtype.ext |
| funext x |
| change fderiv ℝ (fun x => f.1 x*g.1 x) x (A x) = _ |
| rw [fderiv_fun_mul ((smoothFunctionND_contDiff f).differentiable (by simp) x) ((smoothFunctionND_contDiff g).differentiable (by simp) x)] |
| change f.1 x * fderiv ℝ g.1 x (A x) + g.1 x * fderiv ℝ f.1 x (A x) = |
| fderiv ℝ f.1 x (A x) * g.1 x + f.1 x * fderiv ℝ g.1 x (A x) |
| ring |
|
|
| noncomputable def angularWordOperatorND : List (V →L[ℝ] V) → Module.End ℂ (SmoothFunctionND V) |
| | [] => 1 |
| | A::L => angularOperatorND A * angularWordOperatorND L |
|
|
| lemma angularWordOperatorND_append (L K : List (V →L[ℝ] V)) : |
| angularWordOperatorND (L++K)=angularWordOperatorND L*angularWordOperatorND K := by |
| induction L with |
| | nil => simp [angularWordOperatorND] |
| | cons A L ih => simp [angularWordOperatorND,ih,mul_assoc] |
|
|
| def angularWordSplitsND {α : Type*} : List α → List (List α × List α) |
| | [] => [([],[])] |
| | A::L => (angularWordSplitsND L).flatMap (fun p => [(A::p.1,p.2),(p.1,A::p.2)]) |
|
|
| lemma angularWordSplitsND_length {α : Type*} (L : List α) : |
| (angularWordSplitsND L).length=2^L.length := by |
| induction L with |
| | nil => simp [angularWordSplitsND] |
| | cons A L ih => simp [angularWordSplitsND,List.length_flatMap,ih,pow_succ,Nat.mul_comm] |
|
|
| lemma angularWordSplitsND_budget {α : Type*} (L : List α) (p : List α × List α) |
| (hp : p ∈ angularWordSplitsND L) : p.1.length+p.2.length=L.length := by |
| induction L generalizing p with |
| | nil => simp only [angularWordSplitsND,List.mem_singleton] at hp; subst p; rfl |
| | cons A L ih => |
| obtain ⟨q,hq,hpq⟩ := List.mem_flatMap.mp hp |
| have hh := ih q hq |
| simp only [List.mem_cons,List.not_mem_nil,or_false] at hpq |
| rcases hpq with rfl|rfl <;> simp only [List.length_cons] <;> omega |
|
|
| lemma angularWordOperatorND_leibniz (L : List (V →L[ℝ] V)) (f g : SmoothFunctionND V) : |
| angularWordOperatorND L (smoothMulND f g)= |
| ((angularWordSplitsND L).map (fun p => |
| smoothMulND (angularWordOperatorND p.1 f) (angularWordOperatorND p.2 g))).sum := by |
| induction L with |
| | nil => simp [angularWordOperatorND,angularWordSplitsND] |
| | cons A L ih => |
| change angularOperatorND A (angularWordOperatorND L (smoothMulND f g)) = _ |
| rw [ih,map_list_sum] |
| simp only [List.map_map,Function.comp_def,angularOperatorND_mul,angularWordSplitsND, |
| List.flatMap_def,List.map_flatten,List.sum_flatten,List.map_map,List.map_cons,List.map_nil,List.sum_cons,List.sum_nil,add_zero, |
| angularWordOperatorND,Module.End.mul_apply] |
|
|
| lemma angularWordOperatorND_support (L : List (V →L[ℝ] V)) (b : SmoothFunctionND V) : |
| tsupport (angularWordOperatorND L b).1 ⊆ tsupport b.1 := by |
| induction L with |
| | nil => simp [angularWordOperatorND] |
| | cons A L ih => |
| exact (tsupport_angularDerivativeND_subset A (angularWordOperatorND L b).1).trans ih |
|
|
| end CurrentFalconer |
| end GraphLiteralSupport |
| end |
| end |
|
|
| end OAI |
|
|
