| 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 𝒜] |
|
|
| / |
| 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 |
|
|
| / |
| 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 ι] |
|
|
| / |
| 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 |
| |
