Download data/lean/OAI/AlgebraicGeometry/ComplexPoints/Analytic/JacobianRegularity.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 12.7 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/ComplexPoints/Analytic/JacobianRegularity.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/AlgebraicGeometry/ComplexPoints/Analytic/JacobianRegularity.lean
-
curl -L -o JacobianRegularity.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/ComplexPoints/Analytic/JacobianRegularity.lean
12.7 kB
| import OAI.AlgebraicGeometry.Foundations.Scheme.StandardSmoothJacobian | |
| import OAI.AlgebraicGeometry.Foundations.Scheme.SmoothComplexPoint | |
| import OAI.AlgebraicGeometry.ComplexPoints.Analytic.PolynomialDerivative | |
| import Mathlib.Topology.Algebra.Module.FiniteDimension | |
| import Mathlib.LinearAlgebra.Matrix.ToLin | |
| import Mathlib.LinearAlgebra.Determinant | |
| import Mathlib.Analysis.Complex.Basic | |
| /-! # Jacobian Regularity -/ | |
| namespace OAI.AlgebraicGeometry.ComplexPoints.Analytic.JacobianRegularity | |
| noncomputable section | |
| /-! | |
| # Selected Jacobian minors and analytic regularity | |
| The selected coordinates are given by the actual injective map in a | |
| submersive presentation. We split all variables into those in its image and | |
| its complement, preserving the ordering of the selected minor. | |
| -/ | |
| open scoped Classical ContDiff _root_.Topology | |
| open Filter | |
| variable {ΞΉ Ο : Type*} | |
| /-- Variables outside the image of the chosen injection are free coordinates. -/ | |
| abbrev FreeCoordinates (s : Ο β ΞΉ) := {i : ΞΉ // i β Set.range s} | |
| /-- Order the variables as free coordinates followed by the chosen coordinates. | |
| The latter retain exactly the order of the selected Jacobian columns. -/ | |
| def selectedIndexEquiv (s : Ο β ΞΉ) (hs : Function.Injective s) : | |
| FreeCoordinates s β Ο β ΞΉ := | |
| ((Equiv.sumCongr (Equiv.refl _) (Equiv.ofInjective s hs)).trans | |
| (Equiv.sumComm _ _)).trans (Equiv.Set.sumCompl (Set.range s)) | |
| @[simp] | |
| theorem selectedIndexEquiv_free (s : Ο β ΞΉ) (hs : Function.Injective s) | |
| (i : FreeCoordinates s) : selectedIndexEquiv s hs (Sum.inl i) = i.val := by | |
| simp [selectedIndexEquiv, Equiv.Set.sumCompl] | |
| @[simp] | |
| theorem selectedIndexEquiv_selected (s : Ο β ΞΉ) (hs : Function.Injective s) | |
| (j : Ο) : selectedIndexEquiv s hs (Sum.inr j) = s j := by | |
| simp [selectedIndexEquiv, Equiv.Set.sumCompl] | |
| @[simp] | |
| theorem selectedIndexEquiv_symm_free (s : Ο β ΞΉ) (hs : Function.Injective s) | |
| (i : FreeCoordinates s) : (selectedIndexEquiv s hs).symm i.val = Sum.inl i := by | |
| apply (selectedIndexEquiv s hs).injective | |
| simp | |
| @[simp] | |
| theorem selectedIndexEquiv_symm_selected (s : Ο β ΞΉ) (hs : Function.Injective s) | |
| (j : Ο) : (selectedIndexEquiv s hs).symm (s j) = Sum.inr j := by | |
| apply (selectedIndexEquiv s hs).injective | |
| simp | |
| /-- Split a vector into its free coordinates and its selected coordinates. -/ | |
| def splitCoordinates (s : Ο β ΞΉ) (x : ΞΉ β β) : | |
| (FreeCoordinates s β β) Γ (Ο β β) := | |
| (fun i => x i.val, fun j => x (s j)) | |
| /-- Recombining the two coordinate blocks recovers every original coordinate. -/ | |
| theorem splitCoordinates_reconstruct (s : Ο β ΞΉ) (hs : Function.Injective s) | |
| (x : ΞΉ β β) : | |
| (Sum.elim (splitCoordinates s x).1 (splitCoordinates s x).2) β | |
| (selectedIndexEquiv s hs).symm = x := by | |
| have h : Sum.elim (splitCoordinates s x).1 (splitCoordinates s x).2 = | |
| x β selectedIndexEquiv s hs := by | |
| funext j | |
| cases j with | |
| | inl i => simp [splitCoordinates] | |
| | inr j => simp [splitCoordinates] | |
| rw [h] | |
| funext i | |
| simp | |
| /-- The selected/free coordinate decomposition is an actual linear equivalence. -/ | |
| def selectedCoordinateLinearEquiv (s : Ο β ΞΉ) (hs : Function.Injective s) : | |
| (ΞΉ β β) ββ[β] (FreeCoordinates s β β) Γ (Ο β β) where | |
| toFun := splitCoordinates s | |
| invFun z := Sum.elim z.1 z.2 β (selectedIndexEquiv s hs).symm | |
| left_inv := splitCoordinates_reconstruct s hs | |
| right_inv z := by | |
| ext j <;> simp [splitCoordinates] | |
| map_add' _ _ := rfl | |
| map_smul' _ _ := rfl | |
| /-- Rewrite the actual polynomial relations in the selected/free coordinates. -/ | |
| def selectedPolynomialFamily (s : Ο β ΞΉ) (hs : Function.Injective s) | |
| (P : Ο β MvPolynomial ΞΉ β) : Ο β MvPolynomial (FreeCoordinates s β Ο) β := | |
| fun j => MvPolynomial.rename (selectedIndexEquiv s hs).symm (P j) | |
| /-- The reindexed relations have exactly the original values. -/ | |
| theorem selectedPolynomialFamily_eval (s : Ο β ΞΉ) (hs : Function.Injective s) | |
| (P : Ο β MvPolynomial ΞΉ β) (x : ΞΉ β β) (j : Ο) : | |
| MvPolynomial.eval (Sum.elim (splitCoordinates s x).1 (splitCoordinates s x).2) | |
| (selectedPolynomialFamily s hs P j) = MvPolynomial.eval x (P j) := by | |
| rw [selectedPolynomialFamily, MvPolynomial.eval_rename, splitCoordinates_reconstruct] | |
| /-- Differentiation in a selected block coordinate gives precisely that | |
| selected column of the original formal Jacobian, with no rank-only replacement. -/ | |
| theorem selectedPolynomialFamily_pderiv_eval (s : Ο β ΞΉ) (hs : Function.Injective s) | |
| (P : Ο β MvPolynomial ΞΉ β) (x : ΞΉ β β) (j k : Ο) : | |
| MvPolynomial.eval (Sum.elim (splitCoordinates s x).1 (splitCoordinates s x).2) | |
| (MvPolynomial.pderiv (Sum.inr k) (selectedPolynomialFamily s hs P j)) = | |
| MvPolynomial.eval x (MvPolynomial.pderiv (s k) (P j)) := by | |
| rw [selectedPolynomialFamily, β selectedIndexEquiv_symm_selected s hs k, | |
| MvPolynomial.pderiv_rename (selectedIndexEquiv s hs).symm.injective, | |
| MvPolynomial.eval_rename, splitCoordinates_reconstruct] | |
| section FiniteCoordinates | |
| variable [Fintype ΞΉ] | |
| /-- In finite dimensions, the coordinate splitting and its inverse are continuous. -/ | |
| def selectedCoordinateEquiv (s : Ο β ΞΉ) (hs : Function.Injective s) : | |
| (ΞΉ β β) βL[β] (FreeCoordinates s β β) Γ (Ο β β) := | |
| (selectedCoordinateLinearEquiv s hs).toContinuousLinearEquiv | |
| @[simp] | |
| theorem selectedCoordinateEquiv_apply (s : Ο β ΞΉ) (hs : Function.Injective s) | |
| (x : ΞΉ β β) : selectedCoordinateEquiv s hs x = splitCoordinates s x := rfl | |
| end FiniteCoordinates | |
| section Invertibility | |
| variable [Fintype Ο] | |
| /-- An actual continuous linear map is invertible when its columns on the | |
| standard basis form a matrix with nonzero determinant. -/ | |
| theorem isInvertible_of_matrix_columns (L : (Ο β β) βL[β] (Ο β β)) | |
| (M : Matrix Ο Ο β) | |
| (hcolumns : β i j, L (Pi.single j 1) i = M i j) | |
| (hdet : M.det β 0) : L.IsInvertible := by | |
| have hM : LinearMap.toMatrix' L.toLinearMap = M := by | |
| ext i j | |
| simpa only [LinearMap.toMatrix'_apply, ContinuousLinearMap.coe_coe] using hcolumns i j | |
| have hL : L.det β 0 := by | |
| change LinearMap.det L.toLinearMap β 0 | |
| rw [β LinearMap.det_toMatrix', hM] | |
| exact hdet | |
| exact β¨L.toContinuousLinearEquivOfDetNeZero hL, by simpβ© | |
| end Invertibility | |
| section PolynomialDifferential | |
| variable [Fintype ΞΉ] [Fintype Ο] | |
| /-- The usual concatenation of free and selected coordinate vectors. -/ | |
| def sumCoordinateMap : ((ΞΉ β β) Γ (Ο β β)) βL[β] (ΞΉ β Ο β β) := | |
| (LinearEquiv.sumArrowLequivProdArrow ΞΉ Ο β β).symm.toContinuousLinearEquiv.toContinuousLinearMap | |
| @[simp] | |
| theorem sumCoordinateMap_apply (z : (ΞΉ β β) Γ (Ο β β)) : | |
| sumCoordinateMap z = Sum.elim z.1 z.2 := rfl | |
| @[simp] | |
| theorem sumCoordinateMap_selected_single (j : Ο) : | |
| (sumCoordinateMap (ΞΉ := ΞΉ)) (0, Pi.single j (1 : β)) = Pi.single (Sum.inr j) 1 := by | |
| ext k | |
| cases k <;> simp [Pi.single_apply] | |
| /-- The analytic derivative in each selected coordinate is the corresponding | |
| formal partial derivative of the actual polynomial map. -/ | |
| theorem fderiv_splitPolynomialMap_selected_single | |
| (P : Ο β MvPolynomial (ΞΉ β Ο) β) | |
| (u : (ΞΉ β β) Γ (Ο β β)) (j k : Ο) : | |
| (fderiv β (PolynomialImplicit.splitPolynomialMap P) u (0, Pi.single j 1)) k = | |
| MvPolynomial.eval (Sum.elim u.1 u.2) (MvPolynomial.pderiv (Sum.inr j) (P k)) := by | |
| have hd : DifferentiableAt β (PolynomialImplicit.splitPolynomialMap P) u := | |
| (PolynomialImplicit.contDiff_splitPolynomialMap P 1).differentiable_one u | |
| have hc : HasFDerivAt (fun z => PolynomialImplicit.splitPolynomialMap P z k) | |
| ((fderiv β (fun x => MvPolynomial.eval x (P k)) (sumCoordinateMap u)).comp | |
| sumCoordinateMap) u := | |
| (PolynomialDerivative.differentiable_polynomial_eval (P k) (sumCoordinateMap u)).hasFDerivAt.comp u | |
| sumCoordinateMap.hasFDerivAt | |
| have h := congrArg (fun L => L (0, Pi.single j 1)) (fderiv_apply hd k) | |
| rw [hc.fderiv] at h | |
| simp only [ContinuousLinearMap.comp_apply, ContinuousLinearMap.proj_apply] at h | |
| rw [sumCoordinateMap_selected_single, PolynomialDerivative.fderiv_polynomial_eval_single] at h | |
| simpa only [sumCoordinateMap_apply] using h.symm | |
| end PolynomialDifferential | |
| variable {S : Type*} [CommRing S] [Algebra β S] | |
| variable [Fintype ΞΉ] [Fintype Ο] [DecidableEq ΞΉ] | |
| /-- The defining equations of a presentation, in its actual selected/free | |
| coordinate splitting. -/ | |
| def presentationSplitPolynomials (P : Algebra.PreSubmersivePresentation β S ΞΉ Ο) : | |
| Ο β MvPolynomial (FreeCoordinates P.map β Ο) β := | |
| selectedPolynomialFamily P.map P.map_inj P.relation | |
| /-- A field-valued point of the presented algebra in selected/free coordinates. -/ | |
| def presentationSplitPoint (P : Algebra.PreSubmersivePresentation β S ΞΉ Ο) | |
| (x : S ββ[β] β) : (FreeCoordinates P.map β β) Γ (Ο β β) := | |
| splitCoordinates P.map (fun i => x (P.val i)) | |
| omit [Fintype ΞΉ] [Fintype Ο] [DecidableEq ΞΉ] in | |
| /-- Every presented algebra point satisfies the actual reindexed equations. -/ | |
| theorem presentationSplitPoint_zero | |
| (P : Algebra.PreSubmersivePresentation β S ΞΉ Ο) (x : S ββ[β] β) : | |
| PolynomialImplicit.splitPolynomialMap (presentationSplitPolynomials P) (presentationSplitPoint P x) = 0 := by | |
| ext j | |
| change MvPolynomial.eval _ (selectedPolynomialFamily P.map P.map_inj P.relation j) = 0 | |
| simp only [presentationSplitPoint] | |
| rw [selectedPolynomialFamily_eval] | |
| exact Foundations.Scheme.StandardSmoothJacobian.Algebraic.point_relation_zero P.toPresentation x j | |
| /-- The partial analytic derivative is represented by precisely the selected | |
| algebraic Jacobian minor at the algebra point. -/ | |
| theorem presentation_partialDerivative_columns | |
| (P : Algebra.PreSubmersivePresentation β S ΞΉ Ο) (x : S ββ[β] β) (i j : Ο) : | |
| ((fderiv β (PolynomialImplicit.splitPolynomialMap (presentationSplitPolynomials P)) | |
| (presentationSplitPoint P x)).comp | |
| (ContinuousLinearMap.inr β (FreeCoordinates P.map β β) (Ο β β))) | |
| (Pi.single j 1) i = Foundations.Scheme.StandardSmoothJacobian.Algebraic.pointJacobianMinor P x i j := by | |
| change (fderiv β (PolynomialImplicit.splitPolynomialMap (presentationSplitPolynomials P)) | |
| (presentationSplitPoint P x) (0, Pi.single j 1)) i = _ | |
| rw [fderiv_splitPolynomialMap_selected_single] | |
| change MvPolynomial.eval _ | |
| (MvPolynomial.pderiv (Sum.inr j) | |
| (selectedPolynomialFamily P.map P.map_inj P.relation i)) = _ | |
| simp only [presentationSplitPoint] | |
| rw [selectedPolynomialFamily_pderiv_eval] | |
| rfl | |
| /-- Submersive presentation data proves the exact analytic regularity hypothesis | |
| of the implicit function theorem; no analytic rank assumption is added. -/ | |
| theorem standardSmooth_partialDerivative_isInvertible | |
| (P : Algebra.SubmersivePresentation β S ΞΉ Ο) (x : S ββ[β] β) : | |
| ((fderiv β (PolynomialImplicit.splitPolynomialMap | |
| (presentationSplitPolynomials P.toPreSubmersivePresentation)) | |
| (presentationSplitPoint P.toPreSubmersivePresentation x)).comp | |
| (ContinuousLinearMap.inr β (FreeCoordinates P.map β β) (Ο β β))).IsInvertible := by | |
| apply isInvertible_of_matrix_columns _ | |
| (Foundations.Scheme.StandardSmoothJacobian.Algebraic.pointJacobianMinor P.toPreSubmersivePresentation x) | |
| Β· exact presentation_partialDerivative_columns P.toPreSubmersivePresentation x | |
| Β· exact Foundations.Scheme.StandardSmoothJacobian.Algebraic.pointJacobianMinor_det_ne_zero P x | |
| /-- At every field-valued point, the zero set of a standard-smooth presentation | |
| is locally an actual complex analytic graph in its selected coordinates. -/ | |
| theorem exists_standardSmooth_zero_graph | |
| (P : Algebra.SubmersivePresentation β S ΞΉ Ο) (x : S ββ[β] β) : | |
| let Q := presentationSplitPolynomials P.toPreSubmersivePresentation | |
| let u := presentationSplitPoint P.toPreSubmersivePresentation x | |
| β Ο : (FreeCoordinates P.map β β) β (Ο β β), | |
| Ο u.1 = u.2 β§ | |
| ContDiffAt β Ο Ο u.1 β§ | |
| (βαΆ y in π u.1, PolynomialImplicit.splitPolynomialMap Q (y, Ο y) = 0) β§ | |
| (βαΆ z in π u, PolynomialImplicit.splitPolynomialMap Q z = 0 β Ο z.1 = z.2) := by | |
| exact PolynomialImplicit.exists_polynomial_zero_graph | |
| (presentationSplitPolynomials P.toPreSubmersivePresentation) | |
| (presentationSplitPoint P.toPreSubmersivePresentation x) | |
| (presentationSplitPoint_zero P.toPreSubmersivePresentation x) | |
| (standardSmooth_partialDerivative_isInvertible P x) | |
| end | |
| end OAI.AlgebraicGeometry.ComplexPoints.Analytic.JacobianRegularity | |