Download data/lean/OAI/Geometry/Arnold/Volume.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 11.5 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/Arnold/Volume.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/Arnold/Volume.lean
-
curl -L -o Volume.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/Arnold/Volume.lean
11.5 kB
| import OAI.Geometry.Arnold.Homotopy | |
| namespace OAI | |
| universe uE uF | |
| noncomputable section | |
| open scoped BigOperators ContDiff | |
| open MeasureTheory Set Filter | |
| open scoped Matrix.Norms.Operator | |
| open scoped Topology | |
| open Function | |
| open ContinuousAlternatingMap | |
| namespace ArnoldCounterexample.CriticalBound | |
| open ArnoldCounterexample.Forms ContinuousAlternatingMap | |
| local instance : TopologicalSpace RM := | |
| (inferInstance : NormedAddCommGroup RM).toMetricSpace.toPseudoMetricSpace.toUniformSpace.toTopologicalSpace | |
| /-- The Haar integral of a closed horizontal cylinder form is independent of | |
| its slice. The bracket condition is algebraic. -/ | |
| theorem haar_homotopy_invariant | |
| (Ξ : β Γ RM β (β Γ RM) [β^Fin 6]βL[β] β) | |
| (hΞ : ContDiff β β Ξ) (hclosed : β p, extDeriv Ξ p = 0) | |
| (hvertical : β (t : β) (A : O5) (i j : Fin 5), | |
| sliceContraction Ξ t A | |
| (Matrix.vecCons ((A : RM) * (generators i.castSucc * generators j.succ - | |
| generators j.succ * generators i.castSucc)) | |
| (j.removeNth (i.castSucc.removeNth (fun k β¦ (A : RM) * generators k)))) = 0) | |
| (a b : β) : | |
| (β« A : O5, Ξ (a, A) (fun i β¦ (0, (A : RM) * generators i)) βhaar) = | |
| (β« A : O5, Ξ (b, A) (fun i β¦ (0, (A : RM) * generators i)) βhaar) := by | |
| let : CompactSpace O5 := o5_compactSpace | |
| let : BorelSpace O5 := o5_borelSpace | |
| let F : β β O5 β β := fun t A β¦ Ξ (t, A) (fun i β¦ (0, (A : RM) * generators i)) | |
| let D : β β O5 β β := fun t A β¦ | |
| (fderiv β Ξ (t, A) (1, 0)) (fun i β¦ (0, (A : RM) * generators i)) | |
| have hF : Continuous (Function.uncurry F) := by | |
| have h := contDiff_alternating_apply hΞ (v := fun i p β¦ (0, p.2 * generators i)) | |
| (fun i β¦ (contDiff_const : ContDiff β β (fun _ : β Γ RM β¦ (0 : β))).prodMk | |
| (contDiff_snd.mul contDiff_const)) | |
| exact h.continuous.comp (continuous_fst.prodMk (continuous_subtype_val.comp continuous_snd)) | |
| have hD : Continuous (Function.uncurry D) := by | |
| have hd : ContDiff β β (fun p : β Γ RM β¦ fderiv β Ξ p (1, 0)) := | |
| (hΞ.fderiv_right (by simp)).clm_apply contDiff_const | |
| have h := contDiff_alternating_apply hd (v := fun i p β¦ (0, p.2 * generators i)) | |
| (fun i β¦ (contDiff_const : ContDiff β β (fun _ : β Γ RM β¦ (0 : β))).prodMk | |
| (contDiff_snd.mul contDiff_const)) | |
| exact h.continuous.comp (continuous_fst.prodMk (continuous_subtype_val.comp continuous_snd)) | |
| have hd (t : β) (A : O5) : HasDerivAt (fun s β¦ F s A) (D t A) t := by | |
| have h := ((ContinuousAlternatingMap.apply β (β Γ RM) β | |
| (fun i β¦ (0, (A : RM) * generators i))).hasFDerivAt).comp_hasDerivAt t | |
| ((hΞ.differentiable (by simp) (t, A)).hasFDerivAt.comp_hasDerivAt t | |
| ((hasDerivAt_id t).prodMk (hasDerivAt_const t (A : RM)))) | |
| exact h | |
| have dzero (t : β) : β« A : O5, D t A βhaar = 0 := by | |
| have hz := integral_extDeriv_rightMul_eq_zero (sliceContraction Ξ t) | |
| (sliceContraction_contDiff Ξ hΞ t) generators generators_skew (hvertical t) | |
| convert hz using 1 | |
| apply integral_congr_ae | |
| exact Filter.Eventually.of_forall (fun A β¦ | |
| (cylinder_homotopy_identity Ξ (hΞ.differentiable (by simp)) t A | |
| (hclosed (t, A)) (fun i β¦ (A : RM) * generators i)).symm) | |
| have hder (t : β) : HasDerivAt (fun s β¦ β« A, F s A βhaar) 0 t := by | |
| convert hasDerivAt_integral_of_compact haar hF hD hd t using 1 | |
| exact (dzero t).symm | |
| exact is_const_of_deriv_eq_zero (fun t β¦ (hder t).differentiableAt) | |
| (fun t β¦ (hder t).deriv) a b | |
| end ArnoldCounterexample.CriticalBound | |
| namespace ArnoldCounterexample.CriticalBound | |
| open ArnoldCounterexample.Forms ContinuousAlternatingMap | |
| lemma symplectic_velocities (i j : Fin 6) : | |
| symplectic 5 (velocities i) (velocities j) = | |
| if (i, j) β ({(0, 1), (2, 3), (4, 5)} : Finset (Fin 6 Γ Fin 6)) then 1 | |
| else if (j, i) β ({(0, 1), (2, 3), (4, 5)} : Finset (Fin 6 Γ Fin 6)) then -1 else 0 := by | |
| fin_cases i <;> fin_cases j <;> | |
| simp [symplectic_apply, velocities, Fin.sum_univ_succ, Pi.single_apply, | |
| Complex.mul_re, Complex.mul_im, β sq, baseScale_sq] | |
| lemma cubeForm_velocities : cubeForm (symplectic 5) velocities = 48 := by | |
| simp only [cubeForm, pairForm_apply, squareForm_apply _ (symplectic_skew 5)] | |
| simp +decide [Fin.sum_univ_succ, Fin.removeNth, Fin.succAbove, symplectic_velocities] | |
| norm_num | |
| end ArnoldCounterexample.CriticalBound | |
| namespace ArnoldCounterexample.Forms | |
| open ContinuousAlternatingMap | |
| abbrev ProductSpace := CSpace 5 Γ CSpace 3 | |
| def productSymplectic : ProductSpace βL[β] ProductSpace βL[β] β := | |
| (symplectic 5).bilinearComp (.fst β (CSpace 5) (CSpace 3)) (.fst β (CSpace 5) (CSpace 3)) + | |
| (symplectic 3).bilinearComp (.snd β (CSpace 5) (CSpace 3)) (.snd β (CSpace 5) (CSpace 3)) | |
| @[simp] lemma productSymplectic_apply (u v : ProductSpace) : | |
| productSymplectic u v = symplectic 5 u.1 v.1 + symplectic 3 u.2 v.2 := rfl | |
| lemma productSymplectic_skew (u v : ProductSpace) : | |
| productSymplectic u v = -productSymplectic v u := by | |
| simp only [productSymplectic_apply, symplectic_skew 5 u.1 v.1, | |
| symplectic_skew 3 u.2 v.2] | |
| ring | |
| def productNormSq (z : ProductSpace) : β := normSq 5 z.1 + normSq 3 z.2 | |
| lemma productNormSq_contDiff : ContDiff β β productNormSq := | |
| (normSq_contDiff 5 |>.comp contDiff_fst).add (normSq_contDiff 3 |>.comp contDiff_snd) | |
| lemma productNormSq_fderiv (z v : ProductSpace) : | |
| fderiv β productNormSq z v = -productSymplectic (Complex.I β’ z) v := by | |
| have hn5 := (normSq_contDiff 5).differentiable (by simp) | |
| have hn3 := (normSq_contDiff 3).differentiable (by simp) | |
| have hd := ((hn5 z.1).hasFDerivAt.comp z hasFDerivAt_fst).add | |
| ((hn3 z.2).hasFDerivAt.comp z hasFDerivAt_snd) | |
| rw [show fderiv β productNormSq z = _ from hd.fderiv] | |
| simp only [_root_.add_apply, ContinuousLinearMap.comp_apply, ContinuousLinearMap.coe_fst', | |
| ContinuousLinearMap.coe_snd', normSq_fderiv, productSymplectic_apply, Prod.smul_fst, | |
| Prod.smul_snd] | |
| ring | |
| lemma productNormSq_curve_orthogonal {c : β β ProductSpace} {v : ProductSpace} {t : β} | |
| (hc : HasDerivAt c v t) (hunit : β s, productNormSq (c s) = 1) : | |
| productSymplectic (Complex.I β’ c t) v = 0 := by | |
| have hd := (productNormSq_contDiff.differentiable (by simp) (c t)).hasFDerivAt.comp_hasDerivAt t hc | |
| have heq : (fun s β¦ productNormSq (c s)) = fun _ : β β¦ 1 := funext hunit | |
| dsimp only [Function.comp_def] at hd | |
| rw [heq] at hd | |
| have hzero := hd.unique (hasDerivAt_const t 1) | |
| rw [productNormSq_fderiv] at hzero | |
| exact neg_eq_zero.mp hzero | |
| lemma normSq_real_smul (n : β) (a : β) (z : CSpace n) : | |
| normSq n (a β’ z) = a ^ 2 * normSq n z := by | |
| simp [normSq, Pi.smul_apply, Complex.real_smul, Complex.normSq_mul, | |
| Complex.normSq_ofReal, Finset.mul_sum, sq] | |
| /-- Differentiating honest circle equivariance, rather than assuming its | |
| infinitesimal consequence. -/ | |
| lemma fderiv_circle_equivariant {m n : β} (F : CSpace m β CSpace n) | |
| (hF : Differentiable β F) (z : CSpace m) | |
| (hphase : β a : β, Complex.normSq a = 1 β F (a β’ z) = a β’ F z) : | |
| fderiv β F z (Complex.I β’ z) = Complex.I β’ F z := by | |
| let a : β β β := fun t β¦ Complex.exp ((t : β) * Complex.I) | |
| have ha : HasDerivAt a Complex.I 0 := by | |
| simpa [a] using ((Complex.ofRealCLM.hasDerivAt).mul_const Complex.I).cexp (x := (0 : β)) | |
| have ha0 : a 0 = 1 := by simp [a] | |
| have hau (t : β) : Complex.normSq (a t) = 1 := by | |
| simp [a, Complex.normSq_eq_norm_sq, Complex.norm_exp] | |
| have heq : (fun t β¦ F (a t β’ z)) = fun t β¦ a t β’ F z := | |
| funext (fun t β¦ hphase _ (hau t)) | |
| have hd := (hF (a 0 β’ z)).hasFDerivAt.comp_hasDerivAt 0 (ha.smul_const z) | |
| rw [ha0, one_smul] at hd | |
| dsimp only [Function.comp_def] at hd | |
| rw [heq] at hd | |
| exact hd.unique (ha.smul_const (F z)) | |
| end ArnoldCounterexample.Forms | |
| namespace ArnoldCounterexample.Forms | |
| lemma time_slice_hasDerivAt {E : Type uE} {F : Type uF} [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedAddCommGroup F] [NormedSpace β F] | |
| (H : β Γ E β F) (hH : Differentiable β H) (x : E) (t : β) : | |
| HasDerivAt (fun s β¦ H (s, x)) (fderiv β H (t, x) (1, 0)) t := by | |
| exact (hH (t, x)).hasFDerivAt.comp_hasDerivAt t | |
| ((hasDerivAt_id t).prodMk (hasDerivAt_const t x)) | |
| lemma productNormSq_time_tangent {E : Type uE} [NormedAddCommGroup E] [NormedSpace β E] | |
| (H : β Γ E β ProductSpace) (hH : ContDiff β β H) (x : E) | |
| (hunit : β s, productNormSq (H (s, x)) = 1) (t : β) : | |
| productSymplectic (Complex.I β’ H (t, x)) (fderiv β H (t, x) (1, 0)) = 0 := by | |
| apply productNormSq_curve_orthogonal | |
| (time_slice_hasDerivAt H (hH.differentiable (by simp)) x t) hunit | |
| end ArnoldCounterexample.Forms | |
| namespace ArnoldCounterexample.Forms | |
| open ContinuousAlternatingMap | |
| lemma alternating_eq_zero_on_kernel | |
| {E : Type uE} [NormedAddCommGroup E] [NormedSpace β E] [FiniteDimensional β E] | |
| {n : β} (hdim : Module.finrank β E β€ n) | |
| (ΞΈ : E [β^Fin n]βL[β] β) (L : E βL[β] β) (hL : L β 0) | |
| (v : Fin n β E) (hv : β i, L (v i) = 0) : ΞΈ v = 0 := by | |
| apply ΞΈ.toAlternatingMap.map_linearDependent | |
| intro hLI | |
| let v' : Fin n β L.ker := fun i β¦ β¨v i, hv iβ© | |
| have hLI' : LinearIndependent β v' := hLI.of_comp L.ker.subtype | |
| have htop : L.ker β β€ := by | |
| intro ht | |
| apply hL | |
| ext x | |
| have hx : x β L.ker := by rw [ht]; trivial | |
| exact hx | |
| have hc := hLI'.fintype_card_le_finrank | |
| have hlt := Submodule.finrank_lt htop | |
| simp only [Fintype.card_fin] at hc | |
| omega | |
| /-- Six tangent vectors of the unit five-sphere are necessarily dependent. -/ | |
| lemma six_form_vanishes_on_unit_sphere | |
| (ΞΈ : CSpace 3 [β^Fin 6]βL[β] β) (z : CSpace 3) (hz : normSq 3 z = 1) | |
| (v : Fin 6 β CSpace 3) (hv : β i, fderiv β (normSq 3) z (v i) = 0) : | |
| ΞΈ v = 0 := by | |
| apply alternating_eq_zero_on_kernel (L := fderiv β (normSq 3) z) ?_ ΞΈ ?_ v hv | |
| Β· simp [CSpace, Module.finrank_pi_fintype, Complex.finrank_real_complex] | |
| Β· intro h | |
| have hs := normSq_fderiv 3 z z | |
| rw [h] at hs | |
| simp only [_root_.zero_apply, symplectic_I_left] at hs | |
| have heq : (β i : Fin 3, ((z i).re * (z i).re + (z i).im * (z i).im)) = 1 := by | |
| simpa only [normSq, Complex.normSq_apply] using hz | |
| rw [heq] at hs | |
| norm_num at hs | |
| end ArnoldCounterexample.Forms | |
| namespace ArnoldCounterexample.Forms | |
| open ContinuousAlternatingMap | |
| lemma cubeForm_second_radical_on {E : Type uE} [NormedAddCommGroup E] [NormedSpace β E] | |
| (B : E βL[β] E βL[β] β) (hskew : β u v, B u v = -B v u) | |
| (u w : E) (v : Fin 4 β E) (hw : B u w = 0) (hv : β i, B u (v i) = 0) : | |
| cubeForm B (Matrix.vecCons w (Matrix.vecCons u v)) = 0 := by | |
| have hz := cubeForm_radical_on B hskew u (Matrix.vecCons w v) (by | |
| intro i | |
| refine Fin.cases hw (fun j β¦ hv j) i) | |
| have heq : (Matrix.vecCons w (Matrix.vecCons u v)) β Equiv.swap (0 : Fin 6) 1 = | |
| Matrix.vecCons u (Matrix.vecCons w v) := by | |
| ext i | |
| fin_cases i <;> simp [Equiv.swap_apply_def] | |
| have hs := (cubeForm B).toAlternatingMap.map_swap | |
| (Matrix.vecCons w (Matrix.vecCons u v)) (show (0 : Fin 6) β 1 by decide) | |
| rw [heq] at hs | |
| change cubeForm B (Matrix.vecCons u (Matrix.vecCons w v)) = | |
| -cubeForm B (Matrix.vecCons w (Matrix.vecCons u v)) at hs | |
| rw [hz] at hs | |
| exact neg_eq_zero.mp hs.symm | |
| end ArnoldCounterexample.Forms | |
| end | |
| end OAI | |