Download data/lean/OAI/Geometry/Arnold/Homotopy.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 7.94 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/Arnold/Homotopy.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/Arnold/Homotopy.lean
-
curl -L -o Homotopy.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/Arnold/Homotopy.lean
7.94 kB
| import OAI.Geometry.Arnold.Exterior | |
| namespace OAI | |
| universe uE uD uF | |
| noncomputable section | |
| open scoped BigOperators ContDiff | |
| open MeasureTheory Set Filter | |
| open scoped Matrix.Norms.Operator | |
| open scoped Topology | |
| open Function | |
| open ContinuousAlternatingMap | |
| open scoped BigOperators ContDiff | |
| open ContinuousAlternatingMap | |
| namespace ArnoldCounterexample.Forms | |
| variable {E : Type uE} [NormedAddCommGroup E] [NormedSpace β E] | |
| /-- Spatial inclusion in the cylinder. -/ | |
| def spatial : E βL[β] β Γ E := (0 : E βL[β] β).prod (.id β E) | |
| @[simp] lemma spatial_apply (v : E) : spatial v = (0, v) := rfl | |
| /-- Fixed-direction contraction and slice restriction, bundled in norm topology. -/ | |
| def cylinderContraction (n : β) : | |
| ((β Γ E) [β^Fin (n + 1)]βL[β] β) βL[β] (E [β^Fin n]βL[β] β) := | |
| let P : ((β Γ E) [β^Fin n]βL[β] β) βL[β] (E [β^Fin n]βL[β] β) := | |
| (compContinuousLinearMapβ (ΞΉ := Fin n) (N := β) spatial).mkContinuous | |
| (β(spatial : E βL[β] β Γ E)β ^ n) (by | |
| intro ΞΈ | |
| simpa only [compContinuousLinearMapβ, LinearMap.coe_mk, AddHom.coe_mk, | |
| Fintype.card_fin, mul_comm] using ΞΈ.norm_compContinuousLinearMap_le spatial) | |
| P.comp ((ContinuousLinearMap.apply β | |
| ((β Γ E) [β^Fin n]βL[β] β) (1, 0)).comp (curryLeftLI.toContinuousLinearMap)) | |
| @[simp] lemma cylinderContraction_apply (n : β) | |
| (ΞΈ : (β Γ E) [β^Fin (n + 1)]βL[β] β) (v : Fin n β E) : | |
| cylinderContraction n ΞΈ v = ΞΈ (Matrix.vecCons (1, 0) (fun i β¦ (0, v i))) := rfl | |
| def sliceContraction {n : β} | |
| (Ξ : β Γ E β (β Γ E) [β^Fin (n + 1)]βL[β] β) (t : β) : | |
| E β E [β^Fin n]βL[β] β := fun z β¦ cylinderContraction n (Ξ (t, z)) | |
| lemma sliceContraction_contDiff {n : β} | |
| (Ξ : β Γ E β (β Γ E) [β^Fin (n + 1)]βL[β] β) | |
| (hΞ : ContDiff β β Ξ) (t : β) : ContDiff β β (sliceContraction Ξ t) := by | |
| exact (cylinderContraction n).contDiff.comp (hΞ.comp (contDiff_const.prodMk contDiff_id)) | |
| /-- The time derivative of a closed form restricted to slices is the spatial | |
| exterior derivative of its contraction with the time direction. -/ | |
| theorem cylinder_homotopy_identity {n : β} | |
| (Ξ : β Γ E β (β Γ E) [β^Fin (n + 1)]βL[β] β) | |
| (hΞ : Differentiable β Ξ) (t : β) (z : E) | |
| (hclosed : extDeriv Ξ (t, z) = 0) (v : Fin (n + 1) β E) : | |
| extDeriv (sliceContraction Ξ t) z v = | |
| (fderiv β Ξ (t, z) (1, 0)) (fun i β¦ (0, v i)) := by | |
| have hr {k : β} (i : Fin (k + 1)) (w : Fin (k + 1) β β Γ E) : | |
| i.succ.removeNth (Matrix.vecCons (1, 0) w) = | |
| Matrix.vecCons (1, 0) (i.removeNth w) := | |
| Fin.cons_comp_succ_succAbove (1, 0) w i | |
| have hd : fderiv β (sliceContraction Ξ t) z = | |
| (cylinderContraction n).comp ((fderiv β Ξ (t, z)).comp spatial) := by | |
| exact ((cylinderContraction n).hasFDerivAt.comp z | |
| ((hΞ (t, z)).hasFDerivAt.comp z | |
| ((hasFDerivAt_const (c := t) z).prodMk (hasFDerivAt_id z)))).fderiv | |
| have hc : extDeriv Ξ (t, z) (Matrix.vecCons (1, 0) (fun i β¦ (0, v i))) = 0 := by | |
| rw [hclosed]; rfl | |
| simp only [extDeriv, alternatizeUncurryFin_apply] at hc β’ | |
| rw [Fin.sum_univ_succ] at hc | |
| simp only [Matrix.cons_val_zero, Matrix.cons_val_succ, Fin.removeNth_zero, | |
| Fin.val_zero, pow_zero, one_smul, hr, Fin.val_succ, pow_succ, | |
| mul_neg_one, neg_smul, Finset.sum_neg_distrib] at hc | |
| rw [hd] | |
| simp only [ContinuousLinearMap.comp_apply, spatial_apply, cylinderContraction_apply] | |
| have heq : (β i : Fin (n + 1), (-1 : β€) ^ i.val β’ | |
| (fderiv β Ξ (t, z) (0, v i)) | |
| (Matrix.vecCons (1, 0) (fun j β¦ (0, (i.removeNth v) j)))) = | |
| (β i : Fin (n + 1), (-1 : β€) ^ i.val β’ | |
| (fderiv β Ξ (t, z) (0, v i)) | |
| (Matrix.vecCons (1, 0) (i.removeNth (fun j β¦ (0, v j))))) := rfl | |
| rw [heq] | |
| change (fderiv β Ξ (t, z) (1, 0)) (fun i β¦ (0, v i)) - | |
| (β i : Fin (n + 1), (-1 : β€) ^ i.val β’ | |
| (fderiv β Ξ (t, z) (0, v i)) | |
| (Matrix.vecCons (1, 0) (i.removeNth (fun j β¦ (0, v j))))) = 0 at hc | |
| linarith | |
| instance finiteDimensional_multilinear_fin [FiniteDimensional β E] (n : β) : | |
| FiniteDimensional β (E [Γn]βL[β] β) := by | |
| induction n with | |
| | zero => | |
| exact (continuousMultilinearCurryFin0 β E β).symm.toLinearEquiv.finiteDimensional | |
| | succ n ih => | |
| let := ih | |
| exact (continuousMultilinearCurryLeftEquiv β (fun _ : Fin (n + 1) β¦ E) β).symm.toLinearEquiv.finiteDimensional | |
| /-- Smoothness into finite-dimensional alternating forms can be checked after | |
| forgetting alternation. This uses an honest linear retraction, not an axiom. -/ | |
| lemma contDiff_of_toMultilinear {D : Type uD} [NormedAddCommGroup D] [NormedSpace β D] | |
| [FiniteDimensional β E] {n : β} {k : ββΟ} | |
| {f : D β E [β^Fin n]βL[β] β} | |
| (hf : ContDiff β k (fun x β¦ (f x).toContinuousMultilinearMap)) : ContDiff β k f := by | |
| let L := (toContinuousMultilinearMapCLM (π := β) (E := E) (F := β) (ΞΉ := Fin n) β).toLinearMap | |
| have hL : LinearMap.ker L = β₯ := LinearMap.ker_eq_bot.mpr toContinuousMultilinearMap_injective | |
| obtain β¨R, hRβ© := L.exists_leftInverse_of_injective hL | |
| have heq : f = fun x β¦ R.toContinuousLinearMap ((f x).toContinuousMultilinearMap) := by | |
| funext x | |
| exact (LinearMap.congr_fun hR (f x)).symm | |
| rw [heq] | |
| exact R.toContinuousLinearMap.contDiff.comp hf | |
| lemma contDiff_pullback_form {D : Type uD} {F : Type uF} | |
| [NormedAddCommGroup D] [NormedSpace β D] | |
| [NormedAddCommGroup F] [NormedSpace β F] | |
| [FiniteDimensional β E] {n : β} {k : ββΟ} | |
| {ΞΈ : D β F [β^Fin n]βL[β] β} {L : D β E βL[β] F} | |
| (hΞΈ : ContDiff β k ΞΈ) (hL : ContDiff β k L) : | |
| ContDiff β k (fun x β¦ (ΞΈ x).compContinuousLinearMap (L x)) := by | |
| apply contDiff_of_toMultilinear | |
| let : TopologicalSpace (E βL[β] F) := | |
| (inferInstance : NormedAddCommGroup (E βL[β] F)).toMetricSpace.toPseudoMetricSpace.toUniformSpace.toTopologicalSpace | |
| let : TopologicalSpace ((F [Γn]βL[β] β) βL[β] (E [Γn]βL[β] β)) := | |
| (inferInstance : NormedAddCommGroup ((F [Γn]βL[β] β) βL[β] (E [Γn]βL[β] β))).toMetricSpace.toPseudoMetricSpace.toUniformSpace.toTopologicalSpace | |
| let P : ContinuousMultilinearMap β (fun _ : Fin n β¦ E βL[β] F) | |
| ((F [Γn]βL[β] β) βL[β] (E [Γn]βL[β] β)) := | |
| (ContinuousMultilinearMap.compContinuousLinearMapMultilinear | |
| β (fun _ : Fin n β¦ E) (fun _ β¦ F) β).mkContinuous 1 (by | |
| intro g | |
| rw [one_mul] | |
| exact ContinuousMultilinearMap.norm_compContinuousLinearMapL_le β g) | |
| have hPc : ContDiff β k (fun g : Fin n β E βL[β] F β¦ P g) := by | |
| exact ContinuousMultilinearMap.contDiff (π := β) | |
| (E := fun _ : Fin n β¦ E βL[β] F) | |
| (F := (F [Γn]βL[β] β) βL[β] (E [Γn]βL[β] β)) P | |
| have hP := hPc.comp (contDiff_pi.mpr (fun _ β¦ hL)) | |
| exact hP.clm_apply ((toContinuousMultilinearMapCLM (π := β) (E := F) (F := β) (ΞΉ := Fin n) β).contDiff.comp hΞΈ) | |
| /-- Pullback of a constant form is closed. -/ | |
| lemma pullback_constant_closed {D : Type uD} {F : Type uF} | |
| [NormedAddCommGroup D] [NormedSpace β D] | |
| [NormedAddCommGroup F] [NormedSpace β F] | |
| {n : β} (ΞΈ : F [β^Fin n]βL[β] β) (H : D β F) | |
| (hH : ContDiff β β H) (x : D) : | |
| extDeriv (fun y β¦ ΞΈ.compContinuousLinearMap (fderiv β H y)) x = 0 := by | |
| have hΞΈ : DifferentiableAt β (fun _ : F β¦ ΞΈ) (H x) := differentiableAt_const _ | |
| have hH2 : ContDiffAt β 2 H x := hH.contDiffAt.of_le (show (2 : ββΟ) β€ β from WithTop.coe_le_coe.mpr (show (2 : ββ) β€ β€ from le_top)) | |
| have hp := extDeriv_pullback hΞΈ hH2 (by simp) | |
| convert hp using 1 | |
| ext v | |
| simp [extDeriv, alternatizeUncurryFin_apply] | |
| end ArnoldCounterexample.Forms | |
| end | |
| end OAI | |