Download data/lean/OAI/AlgebraicGeometry/StableCoordinate/DerivationTopShift.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 4.97 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/StableCoordinate/DerivationTopShift.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/AlgebraicGeometry/StableCoordinate/DerivationTopShift.lean
-
curl -L -o DerivationTopShift.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/StableCoordinate/DerivationTopShift.lean
4.97 kB
| import Mathlib.RingTheory.GradedAlgebra.Basic | |
| import Mathlib.RingTheory.Derivation.Basic | |
| import Mathlib.Tactic | |
| namespace OAI | |
| /-! | |
| # A maximal degree shift detected on finitely many algebra generators | |
| For an integer-graded algebra, the values of a derivation on finitely many | |
| generators have only finitely many homogeneous components. Thus a nonzero | |
| derivation has a maximal degree shift which is attained on a generator. | |
| These lemmas supply the finite-support step in the leading-derivation | |
| construction of Sections 3 and 5 of the supplied manuscript. | |
| -/ | |
| namespace StableCoordinate | |
| namespace DerivationTopShift | |
| open DirectSum GradedAlgebra | |
| variable {k A ΞΉ : Type*} [CommRing k] [CommRing A] [Algebra k A] | |
| variable (π : β€ β Submodule k A) [GradedAlgebra π] | |
| /-- A nonzero element of an internally graded algebra has a nonzero | |
| homogeneous projection. -/ | |
| theorem exists_proj_ne_zero {a : A} (ha : a β 0) : | |
| β j : β€, proj π j a β 0 := by | |
| classical | |
| by_contra! h | |
| apply ha | |
| apply (DirectSum.decompose π).injective | |
| ext j | |
| simpa using h j | |
| /-- A nonzero derivation cannot vanish on all algebra generators. -/ | |
| theorem exists_generator_ne_zero (g : ΞΉ β A) | |
| (hg : Algebra.adjoin k (Set.range g) = β€) | |
| (D : Derivation k A A) (hD : D β 0) : | |
| β i, D (g i) β 0 := by | |
| by_contra! h | |
| apply hD | |
| apply Derivation.ext_of_adjoin_eq_top (Set.range g) hg | |
| intro a ha | |
| obtain β¨i, rflβ© := ha | |
| simpa using h i | |
| variable [Fintype ΞΉ] | |
| /-- Finitely many generator images admit a maximal degree shift, and for a | |
| nonzero derivation the maximum is attained. No sign restriction is imposed | |
| on generator degrees or on the resulting shift. -/ | |
| theorem exists_maximal_generator_shift (g : ΞΉ β A) (d : ΞΉ β β€) | |
| (hg : Algebra.adjoin k (Set.range g) = β€) | |
| (D : Derivation k A A) (hD : D β 0) : | |
| β m : β€, | |
| (β i j, d i + m < j β proj π j (D (g i)) = 0) β§ | |
| (β i, proj π (d i + m) (D (g i)) β 0) := by | |
| classical | |
| let S : Finset β€ := Finset.univ.biUnion fun i => | |
| ((DirectSum.decompose π (D (g i))).support).image (fun j => j - d i) | |
| have memS (i : ΞΉ) (j : β€) (hj : proj π j (D (g i)) β 0) : j - d i β S := by | |
| apply Finset.mem_biUnion.mpr | |
| refine β¨i, Finset.mem_univ _, ?_β© | |
| apply Finset.mem_image.mpr | |
| exact β¨j, (GradedAlgebra.mem_support_iff π _ _).mpr hj, rflβ© | |
| have hS : S.Nonempty := by | |
| obtain β¨i, hiβ© := exists_generator_ne_zero g hg D hD | |
| obtain β¨j, hjβ© := exists_proj_ne_zero π hi | |
| exact β¨j - d i, memS i j hjβ© | |
| refine β¨S.max' hS, ?_, ?_β© | |
| Β· intro i j hj | |
| by_contra hne | |
| have hle := Finset.le_max' S (j - d i) (memS i j hne) | |
| omega | |
| Β· have hm : S.max' hS β S := Finset.max'_mem S hS | |
| obtain β¨i, _, hiβ© := Finset.mem_biUnion.mp hm | |
| obtain β¨j, hj, heqβ© := Finset.mem_image.mp hi | |
| refine β¨i, ?_β© | |
| have hidx : d i + S.max' hS = j := by omega | |
| rw [hidx] | |
| exact (GradedAlgebra.mem_support_iff π _ _).mp hj | |
| /-- For a family of homogeneous component derivations, vanishing outside the | |
| finite shift support can be tested solely on algebra generators. -/ | |
| theorem exists_maximal_component (g : ΞΉ β A) (d : ΞΉ β β€) | |
| (hg : Algebra.adjoin k (Set.range g) = β€) | |
| (D : Derivation k A A) (hD : D β 0) | |
| (E : β€ β Derivation k A A) | |
| (hE : β m i, E m (g i) = proj π (d i + m) (D (g i))) : | |
| β m : β€, E m β 0 β§ β n, m < n β E n = 0 := by | |
| obtain β¨m, hbound, i, hiβ© := exists_maximal_generator_shift π g d hg D hD | |
| refine β¨m, ?_, ?_β© | |
| Β· intro hzero | |
| apply hi | |
| rw [β hE, hzero] | |
| rfl | |
| Β· intro n hn | |
| apply Derivation.ext_of_adjoin_eq_top (Set.range g) hg | |
| intro a ha | |
| obtain β¨i, rflβ© := ha | |
| rw [hE] | |
| exact hbound i (d i + n) (by omega) | |
| /-- Once homogeneous components are constructed, finite algebra generation | |
| provides a single upper degree-shift bound on every homogeneous input, with | |
| an attained nonzero top derivation. This is the hypothesis needed for the | |
| leading-component local-nilpotence argument. -/ | |
| theorem exists_top_component_and_global_bound | |
| (g : ΞΉ β A) (d : ΞΉ β β€) | |
| (hg : Algebra.adjoin k (Set.range g) = β€) | |
| (hhom : β i, g i β π (d i)) | |
| (D : Derivation k A A) (hD : D β 0) | |
| (E : β€ β Derivation k A A) | |
| (hE : β m i (x : A), x β π i β | |
| E m x = proj π (i + m) (D x)) : | |
| β m : β€, E m β 0 β§ | |
| (β n, m < n β E n = 0) β§ | |
| (β i (x : A), x β π i β β j, i + m < j β proj π j (D x) = 0) := by | |
| obtain β¨m, hm, hmaxβ© := exists_maximal_component π g d hg D hD E | |
| (fun m i => hE m (d i) (g i) (hhom i)) | |
| refine β¨m, hm, hmax, ?_β© | |
| intro i x hx j hj | |
| have heq := hE (j - i) i x hx | |
| have hz := hmax (j - i) (by omega) | |
| rw [hz] at heq | |
| have hidx : i + (j - i) = j := by omega | |
| rw [hidx] at heq | |
| exact heq.symm | |
| end DerivationTopShift | |
| end StableCoordinate | |
| end OAI | |