math / data /lean /OAI /NumberTheory /PadicHodge /IntegralComparison /DividedPower /Localization.lean
Download data/lean/OAI/NumberTheory/PadicHodge/IntegralComparison/DividedPower/Localization.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 9.9 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/NumberTheory/PadicHodge/IntegralComparison/DividedPower/Localization.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/NumberTheory/PadicHodge/IntegralComparison/DividedPower/Localization.lean
-
curl -L -o Localization.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/NumberTheory/PadicHodge/IntegralComparison/DividedPower/Localization.lean
9.9 kB
| import Mathlib | |
| /-! # Localization -/ | |
| namespace OAI.NumberTheory.PadicHodge.IntegralComparison.DividedPower.Localization | |
| noncomputable section | |
| /-! | |
| # IntegralComparison: divided powers on localizations | |
| The construction uses the forced formula γₙ(x/s) = γₙ(x)/sⁿ for x in | |
| the divided-power ideal. Well-definedness allows zero divisors and | |
| localizations in which some elements vanish. | |
| -/ | |
| open _root_.Ideal | |
| universe u v | |
| variable {A : Type u} [CommRing A] {I : Ideal A} (δ : DividedPowers I) | |
| variable (M : Submonoid A) (S : Type v) [CommRing S] [Algebra A S] [IsLocalization M S] | |
| lemma fraction_dpow_congr {x y : A} (hx : x ∈ I) (hy : y ∈ I) (s t : M) | |
| (h : IsLocalization.mk' S x s = IsLocalization.mk' S y t) (n : ℕ) : | |
| IsLocalization.mk' S (δ.dpow n x) (s ^ n) = | |
| IsLocalization.mk' S (δ.dpow n y) (t ^ n) := by | |
| obtain ⟨c, hc⟩ := (IsLocalization.eq (M := M) (S := S)).mp h | |
| apply (IsLocalization.eq (M := M) (S := S)).mpr | |
| refine ⟨c ^ n, ?_⟩ | |
| have he := congrArg (δ.dpow n) hc | |
| simpa only [δ.dpow_mul (I.mul_mem_left _ hx), δ.dpow_mul (I.mul_mem_left _ hy), | |
| δ.dpow_mul hx, δ.dpow_mul hy, SubmonoidClass.coe_pow] using he | |
| lemma ideal_fraction {z : S} (hz : z ∈ I.map (algebraMap A S)) : | |
| ∃ (x : I) (s : M), IsLocalization.mk' S (x : A) s = z := by | |
| obtain ⟨⟨x, s⟩, h⟩ := (IsLocalization.mem_map_algebraMap_iff M S).mp hz | |
| exact ⟨x, s, (IsLocalization.eq_mk'_iff_mul_eq.mpr h).symm⟩ | |
| def numerator (z : S) (hz : z ∈ I.map (algebraMap A S)) : I := | |
| (ideal_fraction M S hz).choose | |
| def denominator (z : S) (hz : z ∈ I.map (algebraMap A S)) : M := | |
| (ideal_fraction M S hz).choose_spec.choose | |
| lemma fraction_spec (z : S) (hz : z ∈ I.map (algebraMap A S)) : | |
| IsLocalization.mk' S (numerator M S z hz : A) (denominator M S z hz) = z := | |
| (ideal_fraction M S hz).choose_spec.choose_spec | |
| def dpow (n : ℕ) (z : S) : S := by | |
| classical | |
| exact if hz : z ∈ I.map (algebraMap A S) then | |
| IsLocalization.mk' S (δ.dpow n (numerator M S z hz)) (denominator M S z hz ^ n) | |
| else 0 | |
| lemma fraction_mem (x : A) (hx : x ∈ I) (s : M) : | |
| IsLocalization.mk' S x s ∈ I.map (algebraMap A S) := | |
| IsLocalization.mk'_mem_iff.mpr (Ideal.mem_map_of_mem _ hx) | |
| lemma dpow_fraction (n : ℕ) {x : A} (hx : x ∈ I) (s : M) : | |
| Localization.dpow δ M S n (IsLocalization.mk' S x s) = | |
| IsLocalization.mk' S (δ.dpow n x) (s ^ n) := by | |
| classical | |
| rw [Localization.dpow, dite_eq_left (fraction_mem M S x hx s)] | |
| exact fraction_dpow_congr δ M S (numerator M S _ _).property hx _ s | |
| (fraction_spec M S _ _) n | |
| lemma dpow_algebraMap (n : ℕ) {x : A} (hx : x ∈ I) : | |
| Localization.dpow δ M S n (algebraMap A S x) = algebraMap A S (δ.dpow n x) := by | |
| rw [← IsLocalization.mk'_one (M := M) S x, dpow_fraction δ M S n hx, | |
| one_pow, IsLocalization.mk'_one] | |
| lemma fraction_sum {ι : Type*} (t : Finset ι) (x : ι → A) (s : M) : | |
| IsLocalization.mk' S (∑ i ∈ t, x i) s = ∑ i ∈ t, IsLocalization.mk' S (x i) s := by | |
| rw [IsLocalization.mk'_eq_mul_mk'_one, map_sum, Finset.sum_mul] | |
| apply Finset.sum_congr rfl | |
| intro i hi | |
| exact (IsLocalization.mk'_eq_mul_mk'_one (S := S) (x i) s).symm | |
| lemma fraction_add_same (x y : A) (s : M) : | |
| IsLocalization.mk' S (x + y) s = IsLocalization.mk' S x s + IsLocalization.mk' S y s := by | |
| rw [IsLocalization.mk'_eq_mul_mk'_one (S := S) (x + y) s, map_add, add_mul, | |
| IsLocalization.mk'_eq_mul_mk'_one (S := S) x s, IsLocalization.mk'_eq_mul_mk'_one (S := S) y s] | |
| lemma fraction_common (x : A) (s t : M) : | |
| IsLocalization.mk' S ((t : A) * x) (t * s) = IsLocalization.mk' S x s := by | |
| rw [IsLocalization.mk'_mul, IsLocalization.mk'_self, one_mul] | |
| lemma ideal_pair_fraction {x y : S} (hx : x ∈ I.map (algebraMap A S)) | |
| (hy : y ∈ I.map (algebraMap A S)) : | |
| ∃ (a b : I) (s : M), IsLocalization.mk' S (a : A) s = x ∧ | |
| IsLocalization.mk' S (b : A) s = y := by | |
| obtain ⟨a, s, rfl⟩ := ideal_fraction M S hx | |
| obtain ⟨b, t, rfl⟩ := ideal_fraction M S hy | |
| refine ⟨⟨(t : A) * a, I.mul_mem_left _ a.property⟩, | |
| ⟨(s : A) * b, I.mul_mem_left _ b.property⟩, t * s, | |
| fraction_common M S _ _ _, ?_⟩ | |
| rw [mul_comm t s] | |
| exact fraction_common M S _ _ _ | |
| lemma dpow_zero {x : S} (hx : x ∈ I.map (algebraMap A S)) : Localization.dpow δ M S 0 x = 1 := by | |
| obtain ⟨a, s, rfl⟩ := ideal_fraction M S hx | |
| rw [dpow_fraction δ M S 0 a.property, δ.dpow_zero a.property, pow_zero, | |
| IsLocalization.mk'_one, map_one] | |
| lemma dpow_one {x : S} (hx : x ∈ I.map (algebraMap A S)) : Localization.dpow δ M S 1 x = x := by | |
| obtain ⟨a, s, rfl⟩ := ideal_fraction M S hx | |
| rw [dpow_fraction δ M S 1 a.property, δ.dpow_one a.property, pow_one] | |
| lemma dpow_mem {n : ℕ} (hn : n ≠ 0) {x : S} (hx : x ∈ I.map (algebraMap A S)) : | |
| Localization.dpow δ M S n x ∈ I.map (algebraMap A S) := by | |
| obtain ⟨a, s, rfl⟩ := ideal_fraction M S hx | |
| rw [dpow_fraction δ M S n a.property] | |
| exact fraction_mem M S _ (δ.dpow_mem hn a.property) _ | |
| lemma dpow_add (n : ℕ) {x y : S} (hx : x ∈ I.map (algebraMap A S)) | |
| (hy : y ∈ I.map (algebraMap A S)) : | |
| Localization.dpow δ M S n (x + y) = | |
| ∑ k ∈ Finset.HasAntidiagonal.antidiagonal n, Localization.dpow δ M S k.1 x * Localization.dpow δ M S k.2 y := by | |
| obtain ⟨a, b, s, rfl, rfl⟩ := ideal_pair_fraction M S hx hy | |
| rw [← fraction_add_same, dpow_fraction δ M S n (I.add_mem a.property b.property), | |
| δ.dpow_add a.property b.property, fraction_sum] | |
| apply Finset.sum_congr rfl | |
| intro k hk | |
| rw [dpow_fraction δ M S k.1 a.property, dpow_fraction δ M S k.2 b.property, | |
| ← IsLocalization.mk'_mul, ← pow_add, Finset.HasAntidiagonal.mem_antidiagonal.mp hk] | |
| lemma dpow_mul (n : ℕ) (a : S) {x : S} (hx : x ∈ I.map (algebraMap A S)) : | |
| Localization.dpow δ M S n (a * x) = a ^ n * Localization.dpow δ M S n x := by | |
| obtain ⟨b, t, rfl⟩ := IsLocalization.exists_mk'_eq M a | |
| obtain ⟨c, s, rfl⟩ := ideal_fraction M S hx | |
| rw [← IsLocalization.mk'_mul, dpow_fraction δ M S n (I.mul_mem_left _ c.property), | |
| dpow_fraction δ M S n c.property, δ.dpow_mul c.property, mul_pow, | |
| IsLocalization.mk'_mul, IsLocalization.mk'_pow] | |
| lemma mul_dpow (m n : ℕ) {x : S} (hx : x ∈ I.map (algebraMap A S)) : | |
| Localization.dpow δ M S m x * Localization.dpow δ M S n x = (Nat.choose (m + n) m : S) * Localization.dpow δ M S (m + n) x := by | |
| obtain ⟨a, s, rfl⟩ := ideal_fraction M S hx | |
| rw [dpow_fraction δ M S m a.property, dpow_fraction δ M S n a.property, | |
| dpow_fraction δ M S (m + n) a.property, ← IsLocalization.mk'_mul, | |
| ← pow_add, δ.mul_dpow a.property, ← IsLocalization.mul_mk'_eq_mk'_of_mul, map_natCast] | |
| lemma dpow_comp (m n : ℕ) (hn : n ≠ 0) {x : S} (hx : x ∈ I.map (algebraMap A S)) : | |
| Localization.dpow δ M S m (Localization.dpow δ M S n x) = (Nat.uniformBell m n : S) * Localization.dpow δ M S (m * n) x := by | |
| obtain ⟨a, s, rfl⟩ := ideal_fraction M S hx | |
| rw [dpow_fraction δ M S n a.property, | |
| dpow_fraction δ M S m (δ.dpow_mem hn a.property), | |
| dpow_fraction δ M S (m * n) a.property, δ.dpow_comp hn a.property, | |
| ← pow_mul, Nat.mul_comm n m, ← IsLocalization.mul_mk'_eq_mk'_of_mul, map_natCast] | |
| def dividedPowers : DividedPowers (I.map (algebraMap A S)) where | |
| dpow := Localization.dpow δ M S | |
| dpow_null hx := by | |
| classical | |
| exact dite_eq_right hx | |
| dpow_zero := Localization.dpow_zero δ M S | |
| dpow_one := Localization.dpow_one δ M S | |
| dpow_mem {n x} hn hx := Localization.dpow_mem δ M S hn hx | |
| dpow_add := Localization.dpow_add δ M S _ | |
| dpow_mul := fun {n a x} hx => Localization.dpow_mul δ M S n a hx | |
| mul_dpow := Localization.mul_dpow δ M S _ _ | |
| dpow_comp {m n _x} hn hx := Localization.dpow_comp δ M S m n hn hx | |
| /-- The original ring maps to its localization as a divided-power ring. -/ | |
| def localizationMap : DividedPowers.DPMorphism δ (dividedPowers δ M S) where | |
| toRingHom := algebraMap A S | |
| ideal_comp := le_rfl | |
| dpow_comp {n} _x hx := dpow_algebraMap δ M S n hx | |
| lemma fraction_power_denominator (x : A) (s : M) (n : ℕ) : | |
| IsLocalization.mk' S x (s ^ n) = | |
| algebraMap A S x * IsLocalization.mk' S 1 s ^ n := by | |
| rw [IsLocalization.mk'_eq_mul_mk'_one, ← IsLocalization.mk'_pow, one_pow] | |
| variable {T : Type*} [CommRing T] {K : Ideal T} (ε : DividedPowers K) | |
| variable (F : S →+* T) | |
| /-- A ring map from a localization is compatible with divided powers as soon | |
| as its restriction to the original ring is compatible. -/ | |
| def mapFromLocalization | |
| (hF : DividedPowers.IsDPMorphism δ ε (F.comp (algebraMap A S))) : | |
| DividedPowers.DPMorphism (dividedPowers δ M S) ε where | |
| toRingHom := F | |
| ideal_comp := by | |
| rw [Ideal.map_map] | |
| exact hF.ideal_comp | |
| dpow_comp {n} z hz := by | |
| obtain ⟨x, s, rfl⟩ := ideal_fraction M S hz | |
| have hx : F (algebraMap A S (x : A)) ∈ K := | |
| hF.ideal_comp (Ideal.mem_map_of_mem _ x.property) | |
| change ε.dpow n (F (IsLocalization.mk' S (x : A) s)) = | |
| F (Localization.dpow δ M S n (IsLocalization.mk' S (x : A) s)) | |
| rw [dpow_fraction δ M S n x.property] | |
| calc | |
| ε.dpow n (F (IsLocalization.mk' S (x : A) s)) = | |
| ε.dpow n (F (IsLocalization.mk' S 1 s) * F (algebraMap A S (x : A))) := by | |
| rw [IsLocalization.mk'_eq_mul_mk'_one (S := S) (x : A) s, map_mul, mul_comm] | |
| _ = F (IsLocalization.mk' S 1 s) ^ n * ε.dpow n (F (algebraMap A S (x : A))) := | |
| ε.dpow_mul hx | |
| _ = F (IsLocalization.mk' S 1 s) ^ n * F (algebraMap A S (δ.dpow n (x : A))) := by | |
| exact congrArg (fun z => F (IsLocalization.mk' S 1 s) ^ n * z) | |
| (hF.dpow_comp (n := n) x x.property) | |
| _ = F (IsLocalization.mk' S (δ.dpow n (x : A)) (s ^ n)) := by | |
| rw [fraction_power_denominator, map_mul, map_pow, mul_comm] | |
| end | |
| end OAI.NumberTheory.PadicHodge.IntegralComparison.DividedPower.Localization | |