openAI-math-dataset / lean /OAI /NumberTheory /PiExponent /Polynomials /GradedLocalizationExact.lean
| import OAI.NumberTheory.PiExponent.Polynomials.GradedSerre | |
| namespace OAI | |
| namespace PiExponent.GradedLocalizationExact | |
| noncomputable section | |
| variable {R M N P σR σM σN σP : Type*} | |
| [CommRing R] [AddCommGroup M] [Module R M] | |
| [AddCommGroup N] [Module R N] [AddCommGroup P] [Module R P] | |
| [SetLike σR R] | |
| [SetLike σM M] [AddSubgroupClass σM M] | |
| [SetLike σN N] [AddSubgroupClass σN N] | |
| [SetLike σP P] [AddSubgroupClass σP P] | |
| def powerDenominator (a : R) (n : ℕ) : Submonoid.powers a := | |
| ⟨a ^ n, ⟨n, rfl⟩⟩ | |
| @[simp] theorem powerDenominator_val (a : R) (n : ℕ) : | |
| (powerDenominator a n : R) = a ^ n := rfl | |
| @[simp] theorem powerDenominator_zero (a : R) : powerDenominator a 0 = 1 := by | |
| apply Subtype.ext | |
| simp [powerDenominator] | |
| theorem powerDenominator_add (a : R) (n k : ℕ) : | |
| powerDenominator a (n + k) = powerDenominator a n * powerDenominator a k := by | |
| apply Subtype.ext | |
| exact pow_add a n k | |
| def fraction (a : R) (m : M) (n : ℕ) : LocalizedModule (Submonoid.powers a) M := | |
| LocalizedModule.mk m (powerDenominator a n) | |
| @[simp] theorem fraction_zero (a : R) (n : ℕ) : fraction a (0 : M) n = 0 := | |
| LocalizedModule.zero_mk _ | |
| @[simp] theorem fraction_neg (a : R) (m : M) (n : ℕ) : | |
| fraction a (-m) n = -fraction a m n := LocalizedModule.mk_neg | |
| theorem fraction_add (a : R) (m m' : M) (n k : ℕ) : | |
| fraction a m n + fraction a m' k = | |
| fraction a (a ^ k • m + a ^ n • m') (n + k) := by | |
| simp only [fraction, powerDenominator_add, LocalizedModule.mk_add_mk, | |
| Submonoid.smul_def, powerDenominator_val] | |
| theorem fraction_cancel (a : R) (m : M) (n k : ℕ) : | |
| fraction a (a ^ k • m) (n + k) = fraction a m n := by | |
| simpa only [fraction, powerDenominator_add, Submonoid.smul_def, | |
| powerDenominator_val] using | |
| LocalizedModule.mk_cancel_common_right (powerDenominator a n) (powerDenominator a k) m | |
| theorem fraction_eq_zero (a : R) (m : M) (n : ℕ) : | |
| fraction a m n = 0 ↔ ∃ k : ℕ, a ^ k • m = 0 := by | |
| rw [← fraction_zero a 0, fraction, fraction, LocalizedModule.mk_eq] | |
| simp only [powerDenominator_zero, one_smul, smul_zero] | |
| constructor | |
| · rintro ⟨s, hs⟩ | |
| obtain ⟨k, hk⟩ := s.property | |
| refine ⟨k, ?_⟩ | |
| simpa only [Submonoid.smul_def, ← hk] using hs | |
| · rintro ⟨k, hk⟩ | |
| exact ⟨powerDenominator a k, hk⟩ | |
| variable (𝒜 : ℤ → σR) (𝓜 : ℤ → σM) | |
| [SetLike.GradedMonoid 𝒜] [SetLike.GradedSMul 𝒜 𝓜] | |
| (a : R) (e : ℤ) (ha : a ∈ 𝒜 e) | |
| omit [AddSubgroupClass σM M] in | |
| include ha in | |
| theorem power_smul_mem {d : ℤ} {m : M} (hm : m ∈ 𝓜 d) (n : ℕ) : | |
| a ^ n • m ∈ 𝓜 (d + (n : ℤ) * e) := by | |
| have h := SetLike.GradedSMul.smul_mem (SetLike.pow_mem_graded n ha) hm | |
| simpa only [nsmul_eq_mul, vadd_eq_add, add_comm] using h | |
| def degreePiece (d : ℤ) : AddSubgroup (LocalizedModule (Submonoid.powers a) M) where | |
| carrier := {z | ∃ (n : ℕ) (m : M), m ∈ 𝓜 (d + (n : ℤ) * e) ∧ z = fraction a m n} | |
| zero_mem' := ⟨0, 0, zero_mem _, (fraction_zero a 0).symm⟩ | |
| add_mem' := by | |
| rintro z z' ⟨n, m, hm, rfl⟩ ⟨k, m', hm', rfl⟩ | |
| refine ⟨n + k, a ^ k • m + a ^ n • m', ?_, fraction_add a m m' n k⟩ | |
| apply add_mem | |
| · have h := power_smul_mem 𝒜 𝓜 a e ha hm k | |
| convert h using 1 | |
| push_cast | |
| ring_nf | |
| · have h := power_smul_mem 𝒜 𝓜 a e ha hm' n | |
| convert h using 1 | |
| push_cast | |
| ring_nf | |
| neg_mem' := by | |
| rintro z ⟨n, m, hm, rfl⟩ | |
| exact ⟨n, -m, neg_mem hm, (fraction_neg a m n).symm⟩ | |
| @[simp] theorem mem_degreePiece (d : ℤ) (z : LocalizedModule (Submonoid.powers a) M) : | |
| z ∈ degreePiece 𝒜 𝓜 a e ha d ↔ | |
| ∃ (n : ℕ) (m : M), m ∈ 𝓜 (d + (n : ℤ) * e) ∧ z = fraction a m n := Iff.rfl | |
| def localizedMap (f : M →ₗ[R] N) : | |
| LocalizedModule (Submonoid.powers a) M →ₗ[R] LocalizedModule (Submonoid.powers a) N := | |
| IsLocalizedModule.map (Submonoid.powers a) (LocalizedModule.mkLinearMap _ M) | |
| (LocalizedModule.mkLinearMap _ N) f | |
| @[simp] theorem localizedMap_fraction (f : M →ₗ[R] N) (m : M) (n : ℕ) : | |
| localizedMap a f (fraction a m n) = fraction a (f m) n := | |
| IsLocalizedModule.map_LocalizedModules _ f m _ | |
| variable (𝓝 : ℤ → σN) [SetLike.GradedSMul 𝒜 𝓝] | |
| def pieceMap (d : ℤ) (f : M →ₗ[R] N) | |
| (hf : ∀ i m, m ∈ 𝓜 i → f m ∈ 𝓝 i) : | |
| degreePiece 𝒜 𝓜 a e ha d →+ degreePiece 𝒜 𝓝 a e ha d where | |
| toFun z := ⟨localizedMap a f z.val, by | |
| obtain ⟨n, m, hm, hz⟩ := z.property | |
| refine ⟨n, f m, hf _ _ hm, ?_⟩ | |
| rw [hz, localizedMap_fraction]⟩ | |
| map_zero' := Subtype.ext (map_zero _) | |
| map_add' z z' := Subtype.ext (map_add _ _ _) | |
| @[simp] theorem pieceMap_coe (d : ℤ) (f : M →ₗ[R] N) | |
| (hf : ∀ i m, m ∈ 𝓜 i → f m ∈ 𝓝 i) | |
| (z : degreePiece 𝒜 𝓜 a e ha d) : | |
| (pieceMap 𝒜 𝓜 a e ha 𝓝 d f hf z).val = localizedMap a f z.val := rfl | |
| section Decomposition | |
| variable [DirectSum.Decomposition 𝓜] [DirectSum.Decomposition 𝓝] | |
| theorem preserves_of_compatible (f : M →ₗ[R] N) | |
| (hf : ∀ i x, f (DirectSum.decompose 𝓜 x i : M) = | |
| (DirectSum.decompose 𝓝 (f x) i : N)) : | |
| ∀ i m, m ∈ 𝓜 i → f m ∈ 𝓝 i := by | |
| intro i m hm | |
| have h := hf i m | |
| rw [DirectSum.decompose_of_mem_same 𝓜 hm] at h | |
| exact h.symm ▸ (DirectSum.decompose 𝓝 (f m) i).property | |
| theorem homogeneous_preimage (f : M →ₗ[R] N) | |
| (hf : ∀ i x, f (DirectSum.decompose 𝓜 x i : M) = | |
| (DirectSum.decompose 𝓝 (f x) i : N)) | |
| {d : ℤ} {y : N} (hy : y ∈ 𝓝 d) (hrange : y ∈ LinearMap.range f) : | |
| ∃ x : M, x ∈ 𝓜 d ∧ f x = y := by | |
| obtain ⟨x, hx⟩ := hrange | |
| refine ⟨DirectSum.decompose 𝓜 x d, (DirectSum.decompose 𝓜 x d).property, ?_⟩ | |
| rw [hf, hx, DirectSum.decompose_of_mem_same 𝓝 hy] | |
| theorem pieceMap_surjective (d : ℤ) (f : M →ₗ[R] N) | |
| (hf : ∀ i x, f (DirectSum.decompose 𝓜 x i : M) = | |
| (DirectSum.decompose 𝓝 (f x) i : N)) (hsurj : Function.Surjective f) : | |
| Function.Surjective | |
| (pieceMap 𝒜 𝓜 a e ha 𝓝 d f (preserves_of_compatible 𝓜 𝓝 f hf)) := by | |
| intro z | |
| obtain ⟨n, y, hy, hz⟩ := z.property | |
| obtain ⟨x, hx, hxy⟩ := homogeneous_preimage 𝓜 𝓝 f hf hy (hsurj y) | |
| refine ⟨⟨fraction a x n, n, x, hx, rfl⟩, ?_⟩ | |
| apply Subtype.ext | |
| change localizedMap a f (fraction a x n) = z.val | |
| rw [localizedMap_fraction, hxy, ← hz] | |
| variable (𝓟 : ℤ → σP) [SetLike.GradedSMul 𝒜 𝓟] [DirectSum.Decomposition 𝓟] | |
| theorem pieceMap_exact (d : ℤ) (f : M →ₗ[R] N) (g : N →ₗ[R] P) | |
| (hf : ∀ i x, f (DirectSum.decompose 𝓜 x i : M) = | |
| (DirectSum.decompose 𝓝 (f x) i : N)) | |
| (hg : ∀ i x, g (DirectSum.decompose 𝓝 x i : N) = | |
| (DirectSum.decompose 𝓟 (g x) i : P)) | |
| (hex : Function.Exact f g) : | |
| Function.Exact | |
| (pieceMap 𝒜 𝓜 a e ha 𝓝 d f (preserves_of_compatible 𝓜 𝓝 f hf)) | |
| (pieceMap 𝒜 𝓝 a e ha 𝓟 d g (preserves_of_compatible 𝓝 𝓟 g hg)) := by | |
| intro z | |
| constructor | |
| · intro hz | |
| obtain ⟨n, y, hy, hzy⟩ := z.property | |
| have hzero : localizedMap a g z.val = 0 := congrArg Subtype.val hz | |
| rw [hzy, localizedMap_fraction, fraction_eq_zero] at hzero | |
| obtain ⟨k, hk⟩ := hzero | |
| have hclear : g (a ^ k • y) = 0 := by rw [map_smul, hk] | |
| have hy' : a ^ k • y ∈ 𝓝 (d + ((n + k : ℕ) : ℤ) * e) := by | |
| have h := power_smul_mem 𝒜 𝓝 a e ha hy k | |
| convert h using 1 | |
| push_cast | |
| ring_nf | |
| obtain ⟨x, hx, hxy⟩ := homogeneous_preimage 𝓜 𝓝 f hf hy' ((hex _).mp hclear) | |
| refine ⟨⟨fraction a x (n + k), n + k, x, hx, rfl⟩, ?_⟩ | |
| apply Subtype.ext | |
| change localizedMap a f (fraction a x (n + k)) = z.val | |
| rw [localizedMap_fraction, hxy, fraction_cancel, ← hzy] | |
| · rintro ⟨x, rfl⟩ | |
| apply Subtype.ext | |
| obtain ⟨n, y, hy, hxy⟩ := x.property | |
| change localizedMap a g (localizedMap a f x.val) = 0 | |
| rw [hxy, localizedMap_fraction, localizedMap_fraction, | |
| hex.apply_apply_eq_zero, fraction_zero] | |
| end Decomposition | |
| section FinitePresentation | |
| variable [AddSubgroupClass σR R] [DirectSum.Decomposition 𝒜] [DirectSum.Decomposition 𝓜] | |
| [IsNoetherianRing R] [Module.Finite R M] | |
| theorem exists_exact_localized_free_presentation : | |
| ∃ (n₀ n₁ : ℕ) (w₀ : Fin n₀ → ℤ) (w₁ : Fin n₁ → ℤ) | |
| (f₀ : (Fin n₀ → R) →ₗ[R] M) | |
| (f₁ : (Fin n₁ → R) →ₗ[R] (Fin n₀ → R)), | |
| ∃ (hf₀ : ∀ i x, | |
| f₀ (DirectSum.decompose (ShiftedFreeGrading.piece 𝒜 w₀) x i : Fin n₀ → R) = | |
| (DirectSum.decompose 𝓜 (f₀ x) i : M)) | |
| (hf₁ : ∀ i x, | |
| f₁ (DirectSum.decompose (ShiftedFreeGrading.piece 𝒜 w₁) x i : Fin n₁ → R) = | |
| (DirectSum.decompose (ShiftedFreeGrading.piece 𝒜 w₀) (f₁ x) i : Fin n₀ → R)), | |
| Function.Surjective f₀ ∧ LinearMap.range f₁ = f₀.ker ∧ | |
| ∀ d : ℤ, | |
| Function.Surjective | |
| (pieceMap 𝒜 (ShiftedFreeGrading.piece 𝒜 w₀) a e ha 𝓜 d f₀ | |
| (preserves_of_compatible (ShiftedFreeGrading.piece 𝒜 w₀) 𝓜 f₀ hf₀)) ∧ | |
| Function.Exact | |
| (pieceMap 𝒜 (ShiftedFreeGrading.piece 𝒜 w₁) a e ha | |
| (ShiftedFreeGrading.piece 𝒜 w₀) d f₁ | |
| (preserves_of_compatible (ShiftedFreeGrading.piece 𝒜 w₁) | |
| (ShiftedFreeGrading.piece 𝒜 w₀) f₁ hf₁)) | |
| (pieceMap 𝒜 (ShiftedFreeGrading.piece 𝒜 w₀) a e ha 𝓜 d f₀ | |
| (preserves_of_compatible (ShiftedFreeGrading.piece 𝒜 w₀) 𝓜 f₀ hf₀)) := by | |
| obtain ⟨n₀, n₁, w₀, w₁, f₀, f₁, hsurj, hex, hf₀, hf₁⟩ := | |
| GradedSerre.exists_graded_free_presentation 𝒜 𝓜 | |
| refine ⟨n₀, n₁, w₀, w₁, f₀, f₁, hf₀, hf₁, hsurj, hex, ?_⟩ | |
| intro d | |
| refine ⟨pieceMap_surjective 𝒜 (ShiftedFreeGrading.piece 𝒜 w₀) a e ha 𝓜 d f₀ hf₀ hsurj, | |
| pieceMap_exact 𝒜 (ShiftedFreeGrading.piece 𝒜 w₁) a e ha | |
| (ShiftedFreeGrading.piece 𝒜 w₀) 𝓜 d f₁ f₀ hf₁ hf₀ ?_⟩ | |
| exact LinearMap.exact_iff.mpr hex.symm | |
| end FinitePresentation | |
| end | |
| end PiExponent.GradedLocalizationExact | |
| end OAI | |