Download data/lean/OAI/Geometry/ProjectionBodies/CosineCalculus.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 13 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/ProjectionBodies/CosineCalculus.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/ProjectionBodies/CosineCalculus.lean
-
curl -L -o CosineCalculus.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/ProjectionBodies/CosineCalculus.lean
13 kB
| import OAI.Geometry.ProjectionBodies.NormEstimates | |
| namespace OAI | |
| noncomputable section | |
| open Set Filter Topology Function | |
| namespace PettyProjection.Spherical | |
| /-- Positive part to a natural power; the endpoint is fixed to zero. -/ | |
| def posPower (r : β) (x : β) : β := if 0 < x then x^r else 0 | |
| lemma posPower_hasDerivAt {r : β} (hr : 2 β€ r) (x : β) : | |
| HasDerivAt (posPower r) ((r : β)*posPower (r-1) x) x := by | |
| have hd (z : β) : HasDerivAt (fun a : β => (a-1)^r) ((r : β)*(z-1)^(r-1)) z := by | |
| convert! ((hasDerivAt_id z).sub_const 1).pow r using 1 | |
| simp | |
| have hp := Scalar.paste_hasDerivAt (fun z _ => hd z) | |
| (by simp [show r β 0 by omega]) (by simp [show r-1 β 0 by omega]) (x+1) | |
| have h := hp.comp x ((hasDerivAt_id x).add_const 1) | |
| convert! h using 1 | |
| Β· funext z; simp [posPower] | |
| Β· simp [posPower, mul_ite] | |
| lemma posPower_contDiff_one {r : β} (hr : 2 β€ r) : ContDiff β 1 (posPower r) := by | |
| have hd (z : β) : HasDerivAt (fun a : β => (a-1)^r) ((r : β)*(z-1)^(r-1)) z := by | |
| convert! ((hasDerivAt_id z).sub_const 1).pow r using 1 | |
| simp | |
| have h := Scalar.paste_contDiff_one (fun z _ => hd z) | |
| (by simp [show r β 0 by omega]) (by simp [show r-1 β 0 by omega]) | |
| (by fun_prop) | |
| have hc := h.comp (contDiff_id.add contDiff_const : ContDiff β 1 (fun x : β => x+1)) | |
| convert! hc using 1 | |
| ext x | |
| simp [posPower] | |
| lemma posPower_contDiff_two {r : β} (hr : 3 β€ r) : ContDiff β 2 (posPower r) := by | |
| have he : deriv (posPower r) = fun x => (r : β)*posPower (r-1) x := | |
| funext fun x => (posPower_hasDerivAt (by omega) x).deriv | |
| change ContDiff β (1+1) (posPower r) | |
| rw [contDiff_succ_iff_deriv] | |
| refine β¨fun x => (posPower_hasDerivAt (by omega) x).differentiableAt, ?_, ?_β© | |
| Β· simp | |
| Β· rw [he] | |
| exact contDiff_const.mul (posPower_contDiff_one (by omega)) | |
| lemma abs_pow_posPower {r : β} (hr : 0 < r) (x : β) : | |
| |x|^r = posPower r x + posPower r (-x) := by | |
| rcases lt_trichotomy x 0 with hx | rfl | hx | |
| Β· simp [posPower, abs_of_neg hx, not_lt.mpr hx.le, neg_pos.mpr hx] | |
| Β· simp [posPower, hr.ne'] | |
| Β· simp [posPower, abs_of_pos hx, hx, not_lt.mpr (neg_nonpos.mpr hx.le)] | |
| lemma abs_pow_contDiff_two {r : β} (hr : 3 β€ r) : ContDiff β 2 (fun x : β => |x|^r) := by | |
| have he : (fun x : β => |x|^r) = fun x => posPower r x+posPower r (-x) := | |
| funext (abs_pow_posPower (by omega)) | |
| rw [he] | |
| exact (posPower_contDiff_two hr).add ((posPower_contDiff_two hr).comp contDiff_neg) | |
| lemma abs_pow_hasDerivAt {r : β} (hr : 2 β€ r) (x : β) : | |
| HasDerivAt (fun x : β => |x|^r) ((r : β)*x*|x|^(r-2)) x := by | |
| have h := (posPower_hasDerivAt hr x).add ((posPower_hasDerivAt hr (-x)).comp x (hasDerivAt_neg x)) | |
| have he : (fun x : β => |x|^r) = fun x => posPower r x+posPower r (-x) := | |
| funext (abs_pow_posPower (by omega)) | |
| rw [he] | |
| convert! h using 1 | |
| have hp : r-1 = (r-2)+1 := by omega | |
| rcases lt_trichotomy x 0 with hx | rfl | hx | |
| Β· simp only [posPower, ite_eq_right (not_lt.mpr hx.le), ite_eq_left (neg_pos.mpr hx), | |
| abs_of_neg hx, hp, pow_succ] | |
| ring | |
| Β· simp [posPower] | |
| Β· simp only [posPower, ite_eq_left hx, ite_eq_right (not_lt.mpr (neg_nonpos.mpr hx.le)), | |
| abs_of_pos hx, hp, pow_succ] | |
| ring | |
| lemma abs_pow_second_deriv {r : β} (hr : 3 β€ r) (x : β) : | |
| HasDerivAt (fun x : β => (r : β)*x*|x|^(r-2)) | |
| ((r : β)*((r : β)-1)*|x|^(r-2)) x := by | |
| have he : (fun x : β => (r : β)*x*|x|^(r-2)) = | |
| fun x => (r : β)*(posPower (r-1) x - posPower (r-1) (-x)) := by | |
| funext z | |
| have hp : r-1 = (r-2)+1 := by omega | |
| rcases lt_trichotomy z 0 with hz | rfl | hz | |
| Β· simp only [posPower, ite_eq_right (not_lt.mpr hz.le), ite_eq_left (neg_pos.mpr hz), | |
| abs_of_neg hz, hp, pow_succ]; ring | |
| Β· simp [posPower] | |
| Β· simp only [posPower, ite_eq_left hz, ite_eq_right (not_lt.mpr (neg_nonpos.mpr hz.le)), | |
| abs_of_pos hz, hp, pow_succ]; ring | |
| rw [he] | |
| have h := ((posPower_hasDerivAt (show 2 β€ r-1 by omega) x).sub | |
| ((posPower_hasDerivAt (show 2 β€ r-1 by omega) (-x)).comp x (hasDerivAt_neg x))).const_mul (r : β) | |
| convert! h using 1 | |
| rw [show r-1-1 = r-2 by omega, Nat.cast_sub (by omega), Nat.cast_one, | |
| abs_pow_posPower (show 0 < r-2 by omega)] | |
| ring | |
| end PettyProjection.Spherical | |
| end | |
| noncomputable section | |
| open Set MeasureTheory Metric Filter Topology Function | |
| open scoped ENNReal RealInnerProductSpace | |
| namespace PettyProjection.Spherical | |
| lemma inner_generator {n : β} (u x : Space n) (i j : Fin n) : | |
| βͺu, generator n i j xβ« = x i*u j-x j*u i := by | |
| simp [generator_apply, inner_sub_right, inner_smul_right, | |
| EuclideanSpace.inner_single_right] | |
| lemma sum_inner_generator_sq {n : β} (u x : Space n) : | |
| β i : Fin n, β j : Fin n, βͺu, generator n i j xβ«^2 = | |
| 2*(βuβ^2*βxβ^2-βͺu,xβ«^2) := by | |
| simp_rw [inner_generator] | |
| have he (i j : Fin n) : (x i*u j-x j*u i)^2 = | |
| x i^2*u j^2+x j^2*u i^2-2*(x i*u i)*(x j*u j) := by ring | |
| simp_rw [he, Finset.sum_sub_distrib, Finset.sum_add_distrib, | |
| β Finset.mul_sum, β Finset.sum_mul] | |
| rw [β EuclideanSpace.real_norm_sq_eq, β EuclideanSpace.real_norm_sq_eq] | |
| simp only [β Finset.mul_sum] | |
| rw [β EuclideanSpace.real_norm_sq_eq] | |
| have hi : βͺu,xβ« = β i, x i*u i := by | |
| simp [EuclideanSpace.inner_eq_star_dotProduct, dotProduct] | |
| rw [hi] | |
| ring | |
| lemma rotDeriv_scalar_linear {n : β} (T : Space n βL[β] Space n) | |
| (L : Space n βL[β] β) {f f' : β β β} | |
| (hf : β t, HasDerivAt f (f' t) t) (x : Space n) : | |
| rotDeriv T (f β L) x = f' (L x)*L (T x) := by | |
| have h := (hf (L x)).comp_hasFDerivAt x L.hasFDerivAt | |
| simp only [rotDeriv, h.fderiv, smul_apply, smul_eq_mul] | |
| lemma rotDeriv_scalar_linear_twice {n : β} (T : Space n βL[β] Space n) | |
| (L : Space n βL[β] β) {f f' f'' : β β β} | |
| (hf : β t, HasDerivAt f (f' t) t) | |
| (hf' : β t, HasDerivAt f' (f'' t) t) (x : Space n) : | |
| rotDeriv T (rotDeriv T (f β L)) x = | |
| f'' (L x)*(L (T x))^2+f' (L x)*L (T (T x)) := by | |
| have he : rotDeriv T (f β L) = fun y => f' (L y)*L (T y) := | |
| funext (rotDeriv_scalar_linear T L hf) | |
| rw [he] | |
| have hd := ((hf' (L x)).comp_hasFDerivAt x L.hasFDerivAt).mul | |
| (L.comp T).hasFDerivAt | |
| change fderiv β ((f' β L) * (fun y => (L.comp T) y)) x (T x) = _ | |
| rw [hd.fderiv] | |
| simp only [add_apply, smul_apply, smul_eq_mul, ContinuousLinearMap.comp_apply, comp_apply] | |
| ring | |
| lemma casimir_scalar_inner {n : β} (u x : Space n) {f f' f'' : β β β} | |
| (hf : β t, HasDerivAt f (f' t) t) | |
| (hf' : β t, HasDerivAt f' (f'' t) t) : | |
| casimir (fun y => f βͺu,yβ«) x = | |
| f'' βͺu,xβ«*(βuβ^2*βxβ^2-βͺu,xβ«^2)- | |
| ((n : β)-1)*f' βͺu,xβ«*βͺu,xβ« := by | |
| change casimir (f β (innerSL β u)) x = _ | |
| unfold casimir | |
| simp_rw [rotDeriv_scalar_linear_twice _ (innerSL β u) hf hf', | |
| innerSL_apply_apply, Finset.sum_add_distrib, β Finset.mul_sum] | |
| rw [sum_inner_generator_sq] | |
| simp_rw [β inner_sum, sum_generator_square, inner_smul_right] | |
| ring | |
| lemma posPower_mul {r : β} (x : β) : | |
| posPower r x*x = posPower (r+1) x := by | |
| by_cases hx : 0 < x <;> simp [posPower, hx, pow_succ] | |
| lemma posPower_mul_sq {r : β} (x : β) : | |
| posPower r x*x^2 = posPower (r+2) x := by | |
| rw [pow_two, β mul_assoc, posPower_mul, posPower_mul] | |
| lemma casimir_posPower_inner {n r : β} (hr : 3 β€ r) (u x : Sphere n) : | |
| casimir (fun y => posPower r βͺ(u : Space n),yβ«) x = | |
| (r : β)*((r : β)-1)*posPower (r-2) βͺ(u : Space n),(x : Space n)β« - | |
| eigenvalue n r*posPower r βͺ(u : Space n),(x : Space n)β« := by | |
| have hd (t : β) : HasDerivAt (fun z => (r : β)*posPower (r-1) z) | |
| ((r : β)*((r : β)-1)*posPower (r-2) t) t := by | |
| convert! (posPower_hasDerivAt (show 2 β€ r-1 by omega) t).const_mul (r : β) using 1 | |
| rw [show r-1-1 = r-2 by omega, Nat.cast_sub (by omega), Nat.cast_one] | |
| ring | |
| rw [casimir_scalar_inner _ _ (posPower_hasDerivAt (by omega)) hd, | |
| norm_coe, norm_coe] | |
| simp only [one_pow, mul_one] | |
| have hβ := posPower_mul (r := r-1) βͺ(u : Space n),(x : Space n)β« | |
| have hβ := posPower_mul_sq (r := r-2) βͺ(u : Space n),(x : Space n)β« | |
| rw [show r-1+1 = r by omega] at hβ | |
| rw [show r-2+2 = r by omega] at hβ | |
| unfold eigenvalue | |
| calc | |
| _ = (r : β)*((r : β)-1)*posPower (r-2) βͺ(u : Space n),(x : Space n)β« - | |
| (r : β)*((r : β)-1)*(posPower (r-2) βͺ(u : Space n),(x : Space n)β« * βͺ(u : Space n),(x : Space n)β«^2) - | |
| ((n : β)-1)*(r : β)*(posPower (r-1) βͺ(u : Space n),(x : Space n)β« * βͺ(u : Space n),(x : Space n)β«) := by ring | |
| _ = _ := by rw [hβ, hβ]; ring | |
| lemma mean_casimir_comm {n : β} [NeZero n] {f g : Space n β β} | |
| (hf : ContDiff β 2 f) (hg : ContDiff β 2 g) : | |
| mean (fun u : Sphere n => f u*casimir g u) = | |
| mean (fun u : Sphere n => g u*casimir f u) := by | |
| rw [mean_casimir (hf.of_le (by norm_num)) hg, | |
| mean_casimir (hg.of_le (by norm_num)) hf, energy_symm] | |
| end PettyProjection.Spherical | |
| end | |
| noncomputable section | |
| open Set MeasureTheory Metric Filter Topology Function | |
| open scoped ENNReal RealInnerProductSpace Gradient | |
| namespace PettyProjection.Spherical | |
| lemma sum_inner_generator_mul {n : β} (u w x : Space n) : | |
| β i : Fin n, β j : Fin n, βͺu,generator n i j xβ«*βͺw,generator n i j xβ« = | |
| 2*(βxβ^2*βͺu,wβ«-βͺu,xβ«*βͺw,xβ«) := by | |
| simp_rw [inner_generator] | |
| have he (i j : Fin n) : (x i*u j-x j*u i)*(x i*w j-x j*w i) = | |
| x i^2*(u j*w j)+x j^2*(u i*w i)-(x i*w i)*(x j*u j)-(x i*u i)*(x j*w j) := by ring | |
| simp_rw [he, Finset.sum_sub_distrib, Finset.sum_add_distrib, | |
| β Finset.mul_sum, β Finset.sum_mul] | |
| have hi (a b : Space n) : βͺa,bβ« = β i, a i*b i := by | |
| simp [EuclideanSpace.inner_eq_star_dotProduct, dotProduct, mul_comm] | |
| rw [hi u w, hi u x, hi w x, EuclideanSpace.real_norm_sq_eq] | |
| simp_rw [mul_comm (u _) (x _), mul_comm (w _) (x _)] | |
| simp only [β Finset.mul_sum] | |
| ring | |
| /-- Genuine tangential gradient on the unit sphere, expressed ambiently. -/ | |
| def sphereGradient {n : β} (f : Space n β β) (x : Space n) : Space n := | |
| β f x - (fderiv β f x x) β’ x | |
| lemma continuous_gradient_of_contDiff {n : β} {f : Space n β β} (hf : ContDiff β 1 f) : | |
| Continuous (gradient f) := | |
| (InnerProductSpace.toDual β (Space n)).symm.continuous.comp (hf.continuous_fderiv (by norm_num)) | |
| lemma sphereGradient_continuous {n : β} {f : Space n β β} (hf : ContDiff β 1 f) : | |
| Continuous (sphereGradient f) := by | |
| exact (continuous_gradient_of_contDiff hf).sub | |
| (((hf.continuous_fderiv (by norm_num)).clm_apply continuous_id).smul continuous_id) | |
| lemma sphereGradient_inner {n : β} (f : Space n β β) (x w : Space n) : | |
| βͺsphereGradient f x,wβ« = fderiv β f x w - fderiv β f x x*βͺx,wβ« := by | |
| simp only [sphereGradient, inner_sub_left, inner_smul_left, inner_gradient_left, starRingEnd_apply, star_trivial] | |
| lemma sphereGradient_tangent {n : β} (f : Space n β β) (x : Sphere n) : | |
| βͺsphereGradient f x,(x : Space n)β« = 0 := by | |
| rw [sphereGradient_inner, real_inner_self_eq_norm_sq, norm_coe] | |
| simp | |
| lemma sum_rotDeriv_inner {n : β} (f : Space n β β) (x : Sphere n) (w : Space n) : | |
| (1/2 : β)*(β i : Fin n, β j : Fin n, | |
| rotDeriv (generator n i j) f x*βͺw,generator n i j xβ«) = βͺsphereGradient f x,wβ« := by | |
| simp only [rotDeriv, β inner_gradient_left] | |
| rw [sum_inner_generator_mul, norm_coe, sphereGradient_inner, | |
| inner_gradient_left, inner_gradient_left, real_inner_comm w (x : Space n)] | |
| ring | |
| lemma mean_gradient_casimir {n : β} [NeZero n] {f g : Space n β β} | |
| (hf : ContDiff β 1 f) (hg : ContDiff β 2 g) : | |
| mean (fun x : Sphere n => βͺsphereGradient f x,sphereGradient g xβ«) = | |
| -mean (fun x : Sphere n => f x*casimir g x) := by | |
| rw [mean_casimir hf hg, neg_neg] | |
| have hs (x : Sphere n) : βͺsphereGradient f x,sphereGradient g xβ« = | |
| (1/2 : β)*β i : Fin n, β j : Fin n, | |
| rotDeriv (generator n i j) f x*rotDeriv (generator n i j) g x := by | |
| have h := sum_rotDeriv_inner f x (β g x) | |
| simp only [inner_gradient_left] at h | |
| change βͺsphereGradient f x, β g x - (fderiv β g x x) β’ (x : Space n)β« = _ | |
| rw [inner_sub_right, inner_smul_right, sphereGradient_tangent, mul_zero, sub_zero] | |
| exact h.symm | |
| simp_rw [hs] | |
| rw [mean, integral_const_mul] | |
| congr 1 | |
| rw [integral_finsetSum] | |
| Β· apply Finset.sum_congr rfl | |
| intro i _ | |
| exact integral_finsetSum _ (fun j _ => continuous_integrable | |
| (((continuous_rotDeriv _ hf).comp continuous_subtype_val).mul | |
| ((continuous_rotDeriv _ (hg.of_le (by norm_num))).comp continuous_subtype_val))) | |
| Β· intro i _ | |
| apply continuous_integrable | |
| exact continuous_finsetSum _ fun j _ => | |
| ((continuous_rotDeriv _ hf).comp continuous_subtype_val).mul | |
| ((continuous_rotDeriv _ (hg.of_le (by norm_num))).comp continuous_subtype_val) | |
| end PettyProjection.Spherical | |
| end | |
| end OAI | |