fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
integerNormalization_coeff (p : S[X]) (i : ℕ) :
(integerNormalization M p).coeff i = coeffIntegerNormalization M p i := by
simp +contextual [integerNormalization, coeff_monomial,
coeffIntegerNormalization_of_coeff_zero] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.Polynomial.Lifts",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Integral.lean | integerNormalization_coeff | null |
integerNormalization_spec (p : S[X]) :
∃ b : M, ∀ i, algebraMap R S ((integerNormalization M p).coeff i) = (b : R) • p.coeff i := by
classical
use Classical.choose (exist_integer_multiples_of_finset M (p.support.image p.coeff))
intro i
rw [integerNormalization_coeff, coeffIntegerNormalization]
split_ifs with hi
· exact
Classical.choose_spec
(Classical.choose_spec (exist_integer_multiples_of_finset M (p.support.image p.coeff))
(p.coeff i) (Finset.mem_image.mpr ⟨i, hi, rfl⟩))
· rw [RingHom.map_zero, notMem_support_iff.mp hi, smul_zero] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.Polynomial.Lifts",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Integral.lean | integerNormalization_spec | null |
integerNormalization_map_to_map (p : S[X]) :
∃ b : M, (integerNormalization M p).map (algebraMap R S) = (b : R) • p :=
let ⟨b, hb⟩ := integerNormalization_spec M p
⟨b,
Polynomial.ext fun i => by
rw [coeff_map, coeff_smul]
exact hb i⟩
variable {R' : Type*} [CommRing R'] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.Polynomial.Lifts",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Integral.lean | integerNormalization_map_to_map | null |
integerNormalization_eval₂_eq_zero (g : S →+* R') (p : S[X]) {x : R'}
(hx : eval₂ g x p = 0) : eval₂ (g.comp (algebraMap R S)) x (integerNormalization M p) = 0 :=
let ⟨b, hb⟩ := integerNormalization_map_to_map M p
_root_.trans (eval₂_map (algebraMap R S) g x).symm
(by rw [hb, ← IsScalarTower.algebraMap_smul S (b : R) p, eval₂_smul, hx, mul_zero]) | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.Polynomial.Lifts",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Integral.lean | integerNormalization_eval₂_eq_zero | null |
integerNormalization_aeval_eq_zero [Algebra R R'] [Algebra S R'] [IsScalarTower R S R']
(p : S[X]) {x : R'} (hx : aeval x p = 0) : aeval x (integerNormalization M p) = 0 := by
rwa [aeval_def, IsScalarTower.algebraMap_eq R S R', integerNormalization_eval₂_eq_zero] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.Polynomial.Lifts",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Integral.lean | integerNormalization_aeval_eq_zero | null |
integerNormalization_eq_zero_iff {p : K[X]} :
integerNormalization (nonZeroDivisors A) p = 0 ↔ p = 0 := by
refine Polynomial.ext_iff.trans (Polynomial.ext_iff.trans ?_).symm
obtain ⟨⟨b, nonzero⟩, hb⟩ := integerNormalization_spec (nonZeroDivisors A) p
constructor <;> intro h i
· rw [coeff_zero, ← to_map_eq_zero_iff (K := K), hb i, h i, coeff_zero, smul_zero]
· have hi := h i
rw [Polynomial.coeff_zero, ← @to_map_eq_zero_iff A _ K, hb i, Algebra.smul_def] at hi
apply Or.resolve_left (eq_zero_or_eq_zero_of_mul_eq_zero hi)
intro h
apply mem_nonZeroDivisors_iff_ne_zero.mp nonzero
exact to_map_eq_zero_iff.mp h
variable (A K C) | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.Polynomial.Lifts",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Integral.lean | integerNormalization_eq_zero_iff | null |
isAlgebraic_iff [Algebra A C] [Algebra K C] [IsScalarTower A K C] {x : C} :
IsAlgebraic A x ↔ IsAlgebraic K x := by
constructor <;> rintro ⟨p, hp, px⟩
· refine ⟨p.map (algebraMap A K), fun h => hp (Polynomial.ext fun i => ?_), ?_⟩
· have : algebraMap A K (p.coeff i) = 0 :=
_root_.trans (Polynomial.coeff_map _ _).symm (by simp [h])
exact to_map_eq_zero_iff.mp this
· exact (Polynomial.aeval_map_algebraMap K _ _).trans px
· exact
⟨integerNormalization _ p, mt integerNormalization_eq_zero_iff.mp hp,
integerNormalization_aeval_eq_zero _ p px⟩
variable {A K C} | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.Polynomial.Lifts",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Integral.lean | isAlgebraic_iff | An element of a ring is algebraic over the ring `A` iff it is algebraic
over the field of fractions of `A`. |
comap_isAlgebraic_iff [Algebra A C] [Algebra K C] [IsScalarTower A K C] :
Algebra.IsAlgebraic A C ↔ Algebra.IsAlgebraic K C :=
⟨fun h => ⟨fun x => (isAlgebraic_iff A K C).mp (h.isAlgebraic x)⟩,
fun h => ⟨fun x => (isAlgebraic_iff A K C).mpr (h.isAlgebraic x)⟩⟩ | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.Polynomial.Lifts",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Integral.lean | comap_isAlgebraic_iff | A ring is algebraic over the ring `A` iff it is algebraic over the field of fractions of `A`. |
RingHom.isIntegralElem_localization_at_leadingCoeff {R S : Type*} [CommSemiring R]
[CommSemiring S] (f : R →+* S) (x : S) (p : R[X]) (hf : p.eval₂ f x = 0) (M : Submonoid R)
(hM : p.leadingCoeff ∈ M) {Rₘ Sₘ : Type*} [CommRing Rₘ] [CommRing Sₘ] [Algebra R Rₘ]
[IsLocalization M Rₘ] [Algebra S Sₘ] [IsLocalization (M.map f : Submonoid S) Sₘ] :
(map Sₘ f M.le_comap_map : Rₘ →+* _).IsIntegralElem (algebraMap S Sₘ x) := by
by_cases triv : (1 : Rₘ) = 0
· exact ⟨0, ⟨_root_.trans leadingCoeff_zero triv.symm, eval₂_zero _ _⟩⟩
haveI : Nontrivial Rₘ := nontrivial_of_ne 1 0 triv
obtain ⟨b, hb⟩ := isUnit_iff_exists_inv.mp (map_units Rₘ ⟨p.leadingCoeff, hM⟩)
refine ⟨p.map (algebraMap R Rₘ) * C b, ⟨?_, ?_⟩⟩
· refine monic_mul_C_of_leadingCoeff_mul_eq_one ?_
rwa [leadingCoeff_map_of_leadingCoeff_ne_zero (algebraMap R Rₘ)]
refine fun hfp => zero_ne_one
(_root_.trans (zero_mul b).symm (hfp ▸ hb) : (0 : Rₘ) = 1)
· refine eval₂_mul_eq_zero_of_left _ _ _ ?_
rw [eval₂_map, IsLocalization.map_comp, ← hom_eval₂ _ f (algebraMap S Sₘ) x]
exact _root_.trans (congr_arg (algebraMap S Sₘ) hf) (RingHom.map_zero _) | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.Polynomial.Lifts",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Integral.lean | RingHom.isIntegralElem_localization_at_leadingCoeff | null |
is_integral_localization_at_leadingCoeff {x : S} (p : R[X]) (hp : aeval x p = 0)
(hM : p.leadingCoeff ∈ M) :
(map Sₘ (algebraMap R S)
(show _ ≤ (Algebra.algebraMapSubmonoid S M).comap _ from M.le_comap_map) :
Rₘ →+* _).IsIntegralElem
(algebraMap S Sₘ x) :=
haveI : IsLocalization (Submonoid.map (algebraMap R S) M) Sₘ :=
inferInstanceAs (IsLocalization (Algebra.algebraMapSubmonoid S M) Sₘ)
(algebraMap R S).isIntegralElem_localization_at_leadingCoeff x p hp M hM | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.Polynomial.Lifts",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Integral.lean | is_integral_localization_at_leadingCoeff | Given a particular witness to an element being algebraic over an algebra `R → S`,
We can localize to a submonoid containing the leading coefficient to make it integral.
Explicitly, the map between the localizations will be an integral ring morphism |
isIntegral_localization [Algebra.IsIntegral R S] :
(map Sₘ (algebraMap R S)
(show _ ≤ (Algebra.algebraMapSubmonoid S M).comap _ from M.le_comap_map) :
Rₘ →+* _).IsIntegral := by
intro x
obtain ⟨⟨s, ⟨u, hu⟩⟩, hx⟩ := surj (Algebra.algebraMapSubmonoid S M) x
obtain ⟨v, hv⟩ := hu
obtain ⟨v', hv'⟩ := isUnit_iff_exists_inv'.1 (map_units Rₘ ⟨v, hv.1⟩)
refine @IsIntegral.of_mul_unit Rₘ _ _ _ (localizationAlgebra M S) x (algebraMap S Sₘ u) v' ?_ ?_
· replace hv' := congr_arg (@algebraMap Rₘ Sₘ _ _ (localizationAlgebra M S)) hv'
rw [RingHom.map_mul, RingHom.map_one, localizationAlgebraMap_def, IsLocalization.map_eq]
at hv'
exact hv.2 ▸ hv'
· obtain ⟨p, hp⟩ := Algebra.IsIntegral.isIntegral (R := R) s
exact hx.symm ▸ is_integral_localization_at_leadingCoeff p hp.2 (hp.1.symm ▸ M.one_mem) | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.Polynomial.Lifts",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Integral.lean | isIntegral_localization | If `R → S` is an integral extension, `M` is a submonoid of `R`,
`Rₘ` is the localization of `R` at `M`,
and `Sₘ` is the localization of `S` at the image of `M` under the extension map,
then the induced map `Rₘ → Sₘ` is also an integral extension |
isIntegral_localization' {R S : Type*} [CommRing R] [CommRing S] {f : R →+* S}
(hf : f.IsIntegral) (M : Submonoid R) :
(map (Localization (M.map (f : R →* S))) f
(M.le_comap_map : _ ≤ Submonoid.comap (f : R →* S) _) :
Localization M →+* _).IsIntegral :=
let _ := f.toAlgebra
have : Algebra.IsIntegral R S := ⟨hf⟩
have : IsLocalization (Algebra.algebraMapSubmonoid S M)
(Localization (Submonoid.map (f : R →* S) M)) := Localization.isLocalization
isIntegral_localization
variable (M) | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.Polynomial.Lifts",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Integral.lean | isIntegral_localization' | null |
IsLocalization.scaleRoots_commonDenom_mem_lifts (p : Rₘ[X])
(hp : p.leadingCoeff ∈ (algebraMap R Rₘ).range) :
p.scaleRoots (algebraMap R Rₘ <| IsLocalization.commonDenom M p.support p.coeff) ∈
Polynomial.lifts (algebraMap R Rₘ) := by
rw [Polynomial.lifts_iff_coeff_lifts]
intro n
rw [Polynomial.coeff_scaleRoots]
by_cases h₁ : n ∈ p.support
on_goal 1 => by_cases h₂ : n = p.natDegree
· rwa [h₂, Polynomial.coeff_natDegree, tsub_self, pow_zero, _root_.mul_one]
· have : n + 1 ≤ p.natDegree := lt_of_le_of_ne (Polynomial.le_natDegree_of_mem_supp _ h₁) h₂
rw [← tsub_add_cancel_of_le (le_tsub_of_add_le_left this), pow_add, pow_one, mul_comm,
_root_.mul_assoc, ← map_pow]
change _ ∈ (algebraMap R Rₘ).range
apply mul_mem
· exact RingHom.mem_range_self _ _
· rw [← Algebra.smul_def]
exact ⟨_, IsLocalization.map_integerMultiple M p.support p.coeff ⟨n, h₁⟩⟩
· rw [Polynomial.notMem_support_iff] at h₁
rw [h₁, zero_mul]
exact zero_mem (algebraMap R Rₘ).range | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.Polynomial.Lifts",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Integral.lean | IsLocalization.scaleRoots_commonDenom_mem_lifts | null |
IsIntegral.exists_multiple_integral_of_isLocalization [Algebra Rₘ S] [IsScalarTower R Rₘ S]
(x : S) (hx : IsIntegral Rₘ x) : ∃ m : M, IsIntegral R (m • x) := by
rcases subsingleton_or_nontrivial Rₘ with _ | nontriv
· haveI := (_root_.algebraMap Rₘ S).codomain_trivial
exact ⟨1, Polynomial.X, Polynomial.monic_X, Subsingleton.elim _ _⟩
obtain ⟨p, hp₁, hp₂⟩ := hx
have :=
lifts_and_natDegree_eq_and_monic (IsLocalization.scaleRoots_commonDenom_mem_lifts M p ?_) ?_
· obtain ⟨p', hp'₁, -, hp'₂⟩ := this
refine ⟨IsLocalization.commonDenom M p.support p.coeff, p', hp'₂, ?_⟩
rw [IsScalarTower.algebraMap_eq R Rₘ S, ← Polynomial.eval₂_map, hp'₁, Submonoid.smul_def,
Algebra.smul_def, IsScalarTower.algebraMap_apply R Rₘ S]
exact Polynomial.scaleRoots_eval₂_eq_zero _ hp₂
· rw [hp₁.leadingCoeff]
exact one_mem _
· rwa [Polynomial.monic_scaleRoots_iff] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.Polynomial.Lifts",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Integral.lean | IsIntegral.exists_multiple_integral_of_isLocalization | null |
isFractionRing_of_algebraic [Algebra.IsAlgebraic A L]
(inj : ∀ x, algebraMap A L x = 0 → x = 0) : IsFractionRing C L :=
{ map_units := fun ⟨y, hy⟩ =>
IsUnit.mk0 _
(show algebraMap C L y ≠ 0 from fun h =>
mem_nonZeroDivisors_iff_ne_zero.mp hy
((injective_iff_map_eq_zero (algebraMap C L)).mp (algebraMap_injective C A L) _ h))
surj := fun z =>
let ⟨x, hx, int⟩ := (Algebra.IsAlgebraic.isAlgebraic z).exists_integral_multiple
⟨⟨mk' C _ int, algebraMap _ _ x, mem_nonZeroDivisors_of_ne_zero fun h ↦
hx (inj _ <| by rw [IsScalarTower.algebraMap_apply A C L, h, RingHom.map_zero])⟩, by
rw [algebraMap_mk', ← IsScalarTower.algebraMap_apply A C L, Algebra.smul_def, mul_comm]⟩
exists_of_eq := fun {x y} h => ⟨1, by simpa using algebraMap_injective C A L h⟩ }
variable (K L) | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.Polynomial.Lifts",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Integral.lean | isFractionRing_of_algebraic | If the field `L` is an algebraic extension of the integral domain `A`,
the integral closure `C` of `A` in `L` has fraction field `L`. |
isFractionRing_of_finite_extension [IsDomain A] [Algebra K L] [IsScalarTower A K L]
[FiniteDimensional K L] : IsFractionRing C L :=
have : Algebra.IsAlgebraic A L := IsFractionRing.comap_isAlgebraic_iff.mpr
(inferInstanceAs (Algebra.IsAlgebraic K L))
isFractionRing_of_algebraic A C
fun _ hx =>
IsFractionRing.to_map_eq_zero_iff.mp
((map_eq_zero <| algebraMap K L).mp <| (IsScalarTower.algebraMap_apply _ _ _ _).symm.trans hx) | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.Polynomial.Lifts",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Integral.lean | isFractionRing_of_finite_extension | If the field `L` is a finite extension of the fraction field of the integral domain `A`,
the integral closure `C` of `A` in `L` has fraction field `L`. |
isFractionRing_of_algebraic [Algebra A L] [Algebra.IsAlgebraic A L]
(inj : ∀ x, algebraMap A L x = 0 → x = 0) : IsFractionRing (integralClosure A L) L :=
IsIntegralClosure.isFractionRing_of_algebraic A (integralClosure A L) inj
variable (K L) | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.Polynomial.Lifts",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Integral.lean | isFractionRing_of_algebraic | If the field `L` is an algebraic extension of the integral domain `A`,
the integral closure of `A` in `L` has fraction field `L`. |
isFractionRing_of_finite_extension [IsDomain A] [Algebra A L] [Algebra K L]
[IsScalarTower A K L] [FiniteDimensional K L] : IsFractionRing (integralClosure A L) L :=
IsIntegralClosure.isFractionRing_of_finite_extension A K L (integralClosure A L) | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.Polynomial.Lifts",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Integral.lean | isFractionRing_of_finite_extension | If the field `L` is a finite extension of the fraction field of the integral domain `A`,
the integral closure of `A` in `L` has fraction field `L`. |
isAlgebraic_iff' [Field K] [IsDomain R] [Algebra R K] [Algebra S K]
[NoZeroSMulDivisors R K] [IsFractionRing S K] [IsScalarTower R S K] :
Algebra.IsAlgebraic R S ↔ Algebra.IsAlgebraic R K := by
simp only [Algebra.isAlgebraic_def]
constructor
· intro h x
letI := MulActionWithZero.nontrivial S K
letI := FractionRing.liftAlgebra R K
have := FractionRing.isScalarTower_liftAlgebra R K
rw [IsFractionRing.isAlgebraic_iff R (FractionRing R) K, isAlgebraic_iff_isIntegral]
obtain ⟨a : S, b, ha, rfl⟩ := div_surjective (A := S) x
obtain ⟨f, hf₁, hf₂⟩ := h b
rw [div_eq_mul_inv]
refine .mul ?_ (.inv ?_) <;> exact isAlgebraic_iff_isIntegral.mp <|
(h _).algebraMap.extendScalars (FaithfulSMul.algebraMap_injective R _)
· intro h x
obtain ⟨f, hf₁, hf₂⟩ := h (algebraMap S K x)
use f, hf₁
rw [Polynomial.aeval_algebraMap_apply] at hf₂
exact
(injective_iff_map_eq_zero (algebraMap S K)).1 (FaithfulSMul.algebraMap_injective _ _) _
hf₂
open nonZeroDivisors
variable {S K} | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.Polynomial.Lifts",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Integral.lean | isAlgebraic_iff' | `S` is algebraic over `R` iff a fraction ring of `S` is algebraic over `R` |
ideal_span_singleton_map_subset {L : Type*} [IsDomain R] [IsDomain S] [Field K] [Field L]
[Algebra R K] [Algebra R L] [Algebra S L] [Algebra.IsAlgebraic R S] [IsFractionRing S L]
[Algebra K L] [IsScalarTower R S L] [IsScalarTower R K L] {a : S} {b : Set S}
(inj : Function.Injective (algebraMap R L))
(h : (Ideal.span ({a} : Set S) : Set S) ⊆ Submodule.span R b) :
(Ideal.span ({algebraMap S L a} : Set L) : Set L) ⊆ Submodule.span K (algebraMap S L '' b) := by
intro x hx
obtain ⟨x', rfl⟩ := Ideal.mem_span_singleton.mp hx
obtain ⟨y', z', rfl⟩ := IsLocalization.mk'_surjective S⁰ x'
obtain ⟨y, z, hz0, yz_eq⟩ :=
Algebra.IsAlgebraic.exists_smul_eq_mul R y' (nonZeroDivisors.coe_ne_zero z')
have injRS : Function.Injective (algebraMap R S) := by
refine
Function.Injective.of_comp (show Function.Injective (algebraMap S L ∘ algebraMap R S) from ?_)
rwa [← RingHom.coe_comp, ← IsScalarTower.algebraMap_eq]
have hz0' : algebraMap R S z ∈ S⁰ :=
map_mem_nonZeroDivisors (algebraMap R S) injRS (mem_nonZeroDivisors_of_ne_zero hz0)
have mk_yz_eq : IsLocalization.mk' L y' z' = IsLocalization.mk' L y ⟨_, hz0'⟩ := by
rw [Algebra.smul_def, mul_comm _ y, mul_comm _ y'] at yz_eq
exact IsLocalization.mk'_eq_of_eq (by rw [mul_comm _ y, mul_comm _ y', yz_eq])
suffices hy : algebraMap S L (a * y) ∈ Submodule.span K ((algebraMap S L) '' b) by
rw [mk_yz_eq, IsFractionRing.mk'_eq_div, ← IsScalarTower.algebraMap_apply,
IsScalarTower.algebraMap_apply R K L, div_eq_mul_inv, ← mul_assoc, mul_comm, ← map_inv₀, ←
Algebra.smul_def, ← map_mul]
exact (Submodule.span K _).smul_mem _ hy
refine Submodule.span_subset_span R K _ ?_
rw [Submodule.span_algebraMap_image_of_tower]
exact Submodule.mem_map_of_mem (f := LinearMap.restrictScalars _ _)
(h (Ideal.mem_span_singleton.mpr ⟨y, rfl⟩)) | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.Polynomial.Lifts",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Integral.lean | ideal_span_singleton_map_subset | If the `S`-multiples of `a` are contained in some `R`-span, then `Frac(S)`-multiples of `a`
are contained in the equivalent `Frac(R)`-span. |
isAlgebraic_of_isFractionRing {R S} (K L) [CommRing R] [CommRing S] [Field K] [CommRing L]
[Algebra R S] [Algebra R K] [Algebra R L] [Algebra S L] [Algebra K L] [IsScalarTower R S L]
[IsScalarTower R K L] [IsFractionRing S L]
[Algebra.IsIntegral R S] : Algebra.IsAlgebraic K L := by
constructor
intro x
obtain ⟨x, s, rfl⟩ := IsLocalization.mk'_surjective S⁰ x
apply IsIntegral.isAlgebraic
rw [IsLocalization.mk'_eq_mul_mk'_one]
apply RingHom.IsIntegralElem.mul
· apply IsIntegral.tower_top (R := R)
apply IsIntegral.map (IsScalarTower.toAlgHom R S L)
exact Algebra.IsIntegral.isIntegral x
· change IsIntegral _ _
rw [← isAlgebraic_iff_isIntegral, ← IsAlgebraic.invOf_iff, isAlgebraic_iff_isIntegral]
apply IsIntegral.tower_top (R := R)
apply IsIntegral.map (IsScalarTower.toAlgHom R S L)
exact Algebra.IsIntegral.isIntegral (s : S) | lemma | RingTheory | [
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.Algebra.Polynomial.Lifts",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Integral.lean | isAlgebraic_of_isFractionRing | null |
invSubmonoid : Submonoid S :=
(M.map (algebraMap R S)).leftInv
variable [IsLocalization M S] | def | RingTheory | [
"Mathlib.GroupTheory.Submonoid.Inverses",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/InvSubmonoid.lean | invSubmonoid | The submonoid of `S = M⁻¹R` consisting of `{ 1 / x | x ∈ M }`. |
submonoid_map_le_is_unit : M.map (algebraMap R S) ≤ IsUnit.submonoid S := by
rintro _ ⟨a, ha, rfl⟩
exact IsLocalization.map_units S ⟨_, ha⟩ | theorem | RingTheory | [
"Mathlib.GroupTheory.Submonoid.Inverses",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/InvSubmonoid.lean | submonoid_map_le_is_unit | null |
noncomputable equivInvSubmonoid : M.map (algebraMap R S) ≃* invSubmonoid M S :=
((M.map (algebraMap R S)).leftInvEquiv (submonoid_map_le_is_unit M S)).symm | abbrev | RingTheory | [
"Mathlib.GroupTheory.Submonoid.Inverses",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/InvSubmonoid.lean | equivInvSubmonoid | There is an equivalence of monoids between the image of `M` and `invSubmonoid`. |
noncomputable toInvSubmonoid : M →* invSubmonoid M S :=
(equivInvSubmonoid M S).toMonoidHom.comp ((algebraMap R S : R →* S).submonoidMap M) | def | RingTheory | [
"Mathlib.GroupTheory.Submonoid.Inverses",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/InvSubmonoid.lean | toInvSubmonoid | There is a canonical map from `M` to `invSubmonoid` sending `x` to `1 / x`. |
toInvSubmonoid_surjective : Function.Surjective (toInvSubmonoid M S) :=
Function.Surjective.comp (β := M.map (algebraMap R S))
(Equiv.surjective (equivInvSubmonoid _ _).toEquiv) (MonoidHom.submonoidMap_surjective _ _)
@[simp] | theorem | RingTheory | [
"Mathlib.GroupTheory.Submonoid.Inverses",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/InvSubmonoid.lean | toInvSubmonoid_surjective | null |
toInvSubmonoid_mul (m : M) : (toInvSubmonoid M S m : S) * algebraMap R S m = 1 :=
Submonoid.leftInvEquiv_symm_mul _ (submonoid_map_le_is_unit _ _) _
@[simp] | theorem | RingTheory | [
"Mathlib.GroupTheory.Submonoid.Inverses",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/InvSubmonoid.lean | toInvSubmonoid_mul | null |
mul_toInvSubmonoid (m : M) : algebraMap R S m * (toInvSubmonoid M S m : S) = 1 :=
Submonoid.mul_leftInvEquiv_symm _ (submonoid_map_le_is_unit _ _) ⟨_, _⟩
@[simp] | theorem | RingTheory | [
"Mathlib.GroupTheory.Submonoid.Inverses",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/InvSubmonoid.lean | mul_toInvSubmonoid | null |
smul_toInvSubmonoid (m : M) : m • (toInvSubmonoid M S m : S) = 1 := by
convert mul_toInvSubmonoid M S m
ext
rw [← Algebra.smul_def]
rfl
variable {S} | theorem | RingTheory | [
"Mathlib.GroupTheory.Submonoid.Inverses",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/InvSubmonoid.lean | smul_toInvSubmonoid | null |
surj'' (z : S) : ∃ (r : R) (m : M), z = r • (toInvSubmonoid M S m : S) := by
rcases IsLocalization.surj M z with ⟨⟨r, m⟩, e : z * _ = algebraMap R S r⟩
refine ⟨r, m, ?_⟩
rw [Algebra.smul_def, ← e, mul_assoc]
simp | theorem | RingTheory | [
"Mathlib.GroupTheory.Submonoid.Inverses",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/InvSubmonoid.lean | surj'' | null |
toInvSubmonoid_eq_mk' (x : M) : (toInvSubmonoid M S x : S) = mk' S 1 x := by
rw [← (IsLocalization.map_units S x).mul_left_inj]
simp | theorem | RingTheory | [
"Mathlib.GroupTheory.Submonoid.Inverses",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/InvSubmonoid.lean | toInvSubmonoid_eq_mk' | null |
mem_invSubmonoid_iff_exists_mk' (x : S) :
x ∈ invSubmonoid M S ↔ ∃ m : M, mk' S 1 m = x := by
simp_rw [← toInvSubmonoid_eq_mk']
exact ⟨fun h => ⟨_, congr_arg Subtype.val (toInvSubmonoid_surjective M S ⟨x, h⟩).choose_spec⟩,
fun h => h.choose_spec ▸ (toInvSubmonoid M S h.choose).prop⟩
variable (S) | theorem | RingTheory | [
"Mathlib.GroupTheory.Submonoid.Inverses",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/InvSubmonoid.lean | mem_invSubmonoid_iff_exists_mk' | null |
span_invSubmonoid : Submodule.span R (invSubmonoid M S : Set S) = ⊤ := by
rw [eq_top_iff]
rintro x -
rcases IsLocalization.surj'' M x with ⟨r, m, rfl⟩
exact Submodule.smul_mem _ _ (Submodule.subset_span (toInvSubmonoid M S m).prop) | theorem | RingTheory | [
"Mathlib.GroupTheory.Submonoid.Inverses",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/InvSubmonoid.lean | span_invSubmonoid | null |
finiteType_of_monoid_fg [Monoid.FG M] : Algebra.FiniteType R S := by
have := Monoid.fg_of_surjective _ (toInvSubmonoid_surjective M S)
rw [Monoid.fg_iff_submonoid_fg] at this
rcases this with ⟨s, hs⟩
refine ⟨⟨s, ?_⟩⟩
rw [eq_top_iff]
rintro x -
change x ∈ (Subalgebra.toSubmodule (Algebra.adjoin R _ : Subalgebra R S) : Set S)
rw [Algebra.adjoin_eq_span, hs, span_invSubmonoid]
trivial | theorem | RingTheory | [
"Mathlib.GroupTheory.Submonoid.Inverses",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/InvSubmonoid.lean | finiteType_of_monoid_fg | null |
@[nolint unusedArguments]
localizationLocalizationSubmodule : Submonoid R :=
(N ⊔ M.map (algebraMap R S)).comap (algebraMap R S)
variable {M N}
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/Localization/LocalizationLocalization.lean | localizationLocalizationSubmodule | Localizing w.r.t. `M ⊆ R` and then w.r.t. `N ⊆ S = M⁻¹R` is equal to the localization of `R`
w.r.t. this module. See `localization_localization_isLocalization`. |
mem_localizationLocalizationSubmodule {x : R} :
x ∈ localizationLocalizationSubmodule M N ↔
∃ (y : N) (z : M), algebraMap R S x = y * algebraMap R S z := by
rw [localizationLocalizationSubmodule, Submonoid.mem_comap, Submonoid.mem_sup]
constructor
· rintro ⟨y, hy, _, ⟨z, hz, rfl⟩, e⟩
exact ⟨⟨y, hy⟩, ⟨z, hz⟩, e.symm⟩
· rintro ⟨y, z, e⟩
exact ⟨y, y.prop, _, ⟨z, z.prop, rfl⟩, e.symm⟩
variable (M N)
variable [IsLocalization M S] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/Localization/LocalizationLocalization.lean | mem_localizationLocalizationSubmodule | null |
localization_localization_map_units [IsLocalization N T]
(y : localizationLocalizationSubmodule M N) : IsUnit (algebraMap R T y) := by
obtain ⟨y', z, eq⟩ := mem_localizationLocalizationSubmodule.mp y.prop
rw [IsScalarTower.algebraMap_apply R S T, eq, RingHom.map_mul, IsUnit.mul_iff]
exact ⟨IsLocalization.map_units T y', (IsLocalization.map_units _ z).map (algebraMap S T)⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/Localization/LocalizationLocalization.lean | localization_localization_map_units | null |
localization_localization_surj [IsLocalization N T] (x : T) :
∃ y : R × localizationLocalizationSubmodule M N,
x * algebraMap R T y.2 = algebraMap R T y.1 := by
rcases IsLocalization.surj N x with ⟨⟨y, s⟩, eq₁⟩
rcases IsLocalization.surj M y with ⟨⟨z, t⟩, eq₂⟩
rcases IsLocalization.surj M (s : S) with ⟨⟨z', t'⟩, eq₃⟩
dsimp only at eq₁ eq₂ eq₃
refine ⟨⟨z * t', z' * t, ?_⟩, ?_⟩ -- x = y / s = (z * t') / (z' * t)
· rw [mem_localizationLocalizationSubmodule]
refine ⟨s, t * t', ?_⟩
rw [RingHom.map_mul, ← eq₃, mul_assoc, ← RingHom.map_mul, mul_comm t, Submonoid.coe_mul]
· simp only [RingHom.map_mul, IsScalarTower.algebraMap_apply R S T, ← eq₃, ← eq₂,
← eq₁]
ring | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/Localization/LocalizationLocalization.lean | localization_localization_surj | null |
localization_localization_exists_of_eq [IsLocalization N T] (x y : R) :
algebraMap R T x = algebraMap R T y →
∃ c : localizationLocalizationSubmodule M N, ↑c * x = ↑c * y := by
rw [IsScalarTower.algebraMap_apply R S T, IsScalarTower.algebraMap_apply R S T,
IsLocalization.eq_iff_exists N T]
rintro ⟨z, eq₁⟩
rcases IsLocalization.surj M (z : S) with ⟨⟨z', s⟩, eq₂⟩
dsimp only at eq₂
suffices (algebraMap R S) (x * z' : R) = (algebraMap R S) (y * z') by
obtain ⟨c, eq₃ : ↑c * (x * z') = ↑c * (y * z')⟩ := (IsLocalization.eq_iff_exists M S).mp this
refine ⟨⟨c * z', ?_⟩, ?_⟩
· rw [mem_localizationLocalizationSubmodule]
refine ⟨z, c * s, ?_⟩
rw [map_mul, ← eq₂, Submonoid.coe_mul, map_mul, mul_left_comm]
· rwa [mul_comm _ z', mul_comm _ z', ← mul_assoc, ← mul_assoc] at eq₃
rw [map_mul, map_mul, ← eq₂, ← mul_assoc, ← mul_assoc, mul_comm _ (z : S), eq₁,
mul_comm _ (z : S)] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/Localization/LocalizationLocalization.lean | localization_localization_exists_of_eq | null |
localization_localization_isLocalization [IsLocalization N T] :
IsLocalization (localizationLocalizationSubmodule M N) T where
map_units := localization_localization_map_units M N T
surj := localization_localization_surj M N T
exists_of_eq := localization_localization_exists_of_eq M N T _ _
include M in | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/Localization/LocalizationLocalization.lean | localization_localization_isLocalization | Given submodules `M ⊆ R` and `N ⊆ S = M⁻¹R`, with `f : R →+* S` the localization map, we have
`N ⁻¹ S = T = (f⁻¹ (N • f(M))) ⁻¹ R`. I.e., the localization of a localization is a localization. |
localization_localization_isLocalization_of_has_all_units [IsLocalization N T]
(H : ∀ x : S, IsUnit x → x ∈ N) : IsLocalization (N.comap (algebraMap R S)) T := by
convert localization_localization_isLocalization M N T using 1
dsimp [localizationLocalizationSubmodule]
congr
symm
rw [sup_eq_left]
rintro _ ⟨x, hx, rfl⟩
exact H _ (IsLocalization.map_units _ ⟨x, hx⟩)
include M in | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/Localization/LocalizationLocalization.lean | localization_localization_isLocalization_of_has_all_units | Given submodules `M ⊆ R` and `N ⊆ S = M⁻¹R`, with `f : R →+* S` the localization map, if
`N` contains all the units of `S`, then `N ⁻¹ S = T = (f⁻¹ N) ⁻¹ R`. I.e., the localization of a
localization is a localization. |
isLocalization_isLocalization_atPrime_isLocalization (p : Ideal S) [Hp : p.IsPrime]
[IsLocalization.AtPrime T p] : IsLocalization.AtPrime T (p.comap (algebraMap R S)) := by
apply localization_localization_isLocalization_of_has_all_units M p.primeCompl T
intro x hx hx'
exact (Hp.1 : ¬_) (p.eq_top_of_isUnit_mem hx' hx) | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/Localization/LocalizationLocalization.lean | isLocalization_isLocalization_atPrime_isLocalization | Given a submodule `M ⊆ R` and a prime ideal `p` of `S = M⁻¹R`, with `f : R →+* S` the localization
map, then `T = Sₚ` is the localization of `R` at `f⁻¹(p)`. |
isLocalization_atPrime_localization_atPrime (p : Ideal (Localization M))
[p.IsPrime] : IsLocalization.AtPrime (Localization.AtPrime p) (p.comap (algebraMap R _)) :=
isLocalization_isLocalization_atPrime_isLocalization M _ _ | instance | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/Localization/LocalizationLocalization.lean | isLocalization_atPrime_localization_atPrime | null |
noncomputable localizationLocalizationAtPrimeIsoLocalization (p : Ideal (Localization M))
[p.IsPrime] :
Localization.AtPrime (p.comap (algebraMap R (Localization M))) ≃ₐ[R] Localization.AtPrime p :=
IsLocalization.algEquiv (p.comap (algebraMap R (Localization M))).primeCompl _ _ | def | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/Localization/LocalizationLocalization.lean | localizationLocalizationAtPrimeIsoLocalization | Given a submodule `M ⊆ R` and a prime ideal `p` of `M⁻¹R`, with `f : R →+* S` the localization
map, then `(M⁻¹R)ₚ` is isomorphic (as an `R`-algebra) to the localization of `R` at `f⁻¹(p)`. |
noncomputable localizationAlgebraOfSubmonoidLe (M N : Submonoid R) (h : M ≤ N)
[IsLocalization M S] [IsLocalization N T] : Algebra S T :=
(@IsLocalization.lift R _ M S _ _ T _ _ (algebraMap R T)
(fun y => map_units T ⟨↑y, h y.prop⟩)).toAlgebra | abbrev | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/Localization/LocalizationLocalization.lean | localizationAlgebraOfSubmonoidLe | Given submonoids `M ≤ N` of `R`, this is the canonical algebra structure
of `M⁻¹S` acting on `N⁻¹S`. |
localization_isScalarTower_of_submonoid_le (M N : Submonoid R) (h : M ≤ N)
[IsLocalization M S] [IsLocalization N T] :
@IsScalarTower R S T _ (localizationAlgebraOfSubmonoidLe S T M N h).toSMul _ :=
letI := localizationAlgebraOfSubmonoidLe S T M N h
IsScalarTower.of_algebraMap_eq' (IsLocalization.lift_comp _).symm | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/Localization/LocalizationLocalization.lean | localization_isScalarTower_of_submonoid_le | If `M ≤ N` are submonoids of `R`, then the natural map `M⁻¹S →+* N⁻¹S` commutes with the
localization maps |
noncomputable instAlgebraLocalizationAtPrime (x : Ideal R) [H : x.IsPrime] [IsDomain R] :
Algebra (Localization.AtPrime x) (Localization (nonZeroDivisors R)) :=
localizationAlgebraOfSubmonoidLe _ _ x.primeCompl (nonZeroDivisors R)
(by
intro a ha
rw [mem_nonZeroDivisors_iff_ne_zero]
exact fun h => ha (h.symm ▸ x.zero_mem)) | instance | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/Localization/LocalizationLocalization.lean | instAlgebraLocalizationAtPrime | null |
isLocalization_of_submonoid_le (M N : Submonoid R) (h : M ≤ N) [IsLocalization M S]
[IsLocalization N T] [Algebra S T] [IsScalarTower R S T] :
IsLocalization (N.map (algebraMap R S)) T where
map_units := by
rintro ⟨_, ⟨y, hy, rfl⟩⟩
convert IsLocalization.map_units T ⟨y, hy⟩
exact (IsScalarTower.algebraMap_apply _ _ _ _).symm
surj y := by
obtain ⟨⟨x, s⟩, e⟩ := IsLocalization.surj N y
refine ⟨⟨algebraMap R S x, _, _, s.prop, rfl⟩, ?_⟩
simpa [← IsScalarTower.algebraMap_apply] using e
exists_of_eq {x₁ x₂} := by
obtain ⟨⟨y₁, s₁⟩, e₁⟩ := IsLocalization.surj M x₁
obtain ⟨⟨y₂, s₂⟩, e₂⟩ := IsLocalization.surj M x₂
refine (Set.exists_image_iff (algebraMap R S) N fun c => c * x₁ = c * x₂).mpr.comp ?_
dsimp only at e₁ e₂ ⊢
suffices algebraMap R T (y₁ * s₂) = algebraMap R T (y₂ * s₁) →
∃ a : N, algebraMap R S (a * (y₁ * s₂)) = algebraMap R S (a * (y₂ * s₁)) by
have h₁ := @IsUnit.mul_left_inj T _ _ (algebraMap S T x₁) (algebraMap S T x₂)
(IsLocalization.map_units T ⟨(s₁ : R), h s₁.prop⟩)
have h₂ := @IsUnit.mul_left_inj T _ _ ((algebraMap S T x₁) * (algebraMap R T s₁))
((algebraMap S T x₂) * (algebraMap R T s₁))
(IsLocalization.map_units T ⟨(s₂ : R), h s₂.prop⟩)
simp only [IsScalarTower.algebraMap_apply R S T] at h₁ h₂
simp only [IsScalarTower.algebraMap_apply R S T, map_mul, ← e₁, ← e₂, ← mul_assoc,
mul_right_comm _ (algebraMap R S s₂),
(IsLocalization.map_units S s₁).mul_left_inj,
(IsLocalization.map_units S s₂).mul_left_inj] at this
rw [h₂, h₁] at this
simpa only [mul_comm] using this
simp_rw [IsLocalization.eq_iff_exists N T, IsLocalization.eq_iff_exists M S]
intro ⟨a, e⟩
exact ⟨a, 1, by convert e using 1 <;> simp⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/Localization/LocalizationLocalization.lean | isLocalization_of_submonoid_le | If `M ≤ N` are submonoids of `R`, then `N⁻¹S` is also the localization of `M⁻¹S` at `N`. |
isLocalization_of_is_exists_mul_mem (M N : Submonoid R) [IsLocalization M S] (h : M ≤ N)
(h' : ∀ x : N, ∃ m : R, m * x ∈ M) : IsLocalization N S where
map_units y := by
obtain ⟨m, hm⟩ := h' y
have := IsLocalization.map_units S ⟨_, hm⟩
rw [map_mul] at this
exact (IsUnit.mul_iff.mp this).2
surj z := by
obtain ⟨⟨y, s⟩, e⟩ := IsLocalization.surj M z
exact ⟨⟨y, _, h s.prop⟩, e⟩
exists_of_eq {_ _} := by
rw [IsLocalization.eq_iff_exists M]
exact fun ⟨x, hx⟩ => ⟨⟨_, h x.prop⟩, hx⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/Localization/LocalizationLocalization.lean | isLocalization_of_is_exists_mul_mem | If `M ≤ N` are submonoids of `R` such that `∀ x : N, ∃ m : R, m * x ∈ M`, then the
localization at `N` is equal to the localization of `M`. |
mk'_eq_algebraMap_mk'_of_submonoid_le {M N : Submonoid R} (h : M ≤ N) [IsLocalization M S]
[IsLocalization N T] [Algebra S T] [IsScalarTower R S T] (x : R) (y : {a : R // a ∈ M}) :
mk' T x ⟨y.1, h y.2⟩ = algebraMap S T (mk' S x y) :=
mk'_eq_iff_eq_mul.mpr (by simp only [IsScalarTower.algebraMap_apply R S T, ← map_mul, mk'_spec]) | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/Localization/LocalizationLocalization.lean | mk'_eq_algebraMap_mk'_of_submonoid_le | null |
isFractionRing_of_isLocalization (S T : Type*) [CommRing S] [CommRing T] [Algebra R S]
[Algebra R T] [Algebra S T] [IsScalarTower R S T] [IsLocalization M S] [IsFractionRing R T]
(hM : M ≤ nonZeroDivisors R) : IsFractionRing S T := by
have := isLocalization_of_submonoid_le S T M (nonZeroDivisors R) hM
refine @isLocalization_of_is_exists_mul_mem _ _ _ _ _ _ _ this ?_ ?_
· exact map_nonZeroDivisors_le M S
· rintro ⟨x, -, hx⟩
obtain ⟨⟨y, s⟩, e⟩ := IsLocalization.surj M x
use algebraMap R S s
rw [mul_comm, Subtype.coe_mk, e]
refine Set.mem_image_of_mem (algebraMap R S) (mem_nonZeroDivisors_iff_right.mpr ?_)
intro z hz
apply IsLocalization.injective S hM
rw [map_zero]
apply hx
rw [← (map_units S s).mul_left_inj, mul_assoc, e, ← map_mul, hz, map_zero,
zero_mul] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/Localization/LocalizationLocalization.lean | isFractionRing_of_isLocalization | null |
isFractionRing_of_isDomain_of_isLocalization [IsDomain R] (S T : Type*) [CommRing S]
[CommRing T] [Algebra R S] [Algebra R T] [Algebra S T] [IsScalarTower R S T]
[IsLocalization M S] [IsFractionRing R T] : IsFractionRing S T := by
haveI := IsFractionRing.nontrivial R T
haveI := (algebraMap S T).domain_nontrivial
apply isFractionRing_of_isLocalization M S T
intro x hx
rw [mem_nonZeroDivisors_iff_ne_zero]
intro hx'
apply @zero_ne_one S
rw [← (algebraMap R S).map_one, ← @mk'_one R _ M, @comm _ Eq, mk'_eq_zero_iff]
exact ⟨⟨x, hx⟩, by simp [hx']⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.FractionRing"
] | Mathlib/RingTheory/Localization/LocalizationLocalization.lean | isFractionRing_of_isDomain_of_isLocalization | null |
span_eq_top_of_isLocalizedModule {v : Set M} (hv : span R v = ⊤) :
span Rₛ (f '' v) = ⊤ := top_unique fun x _ ↦ by
obtain ⟨⟨m, s⟩, h⟩ := IsLocalizedModule.surj S f x
rw [Submonoid.smul_def, ← algebraMap_smul Rₛ, ← Units.smul_isUnit (IsLocalization.map_units Rₛ s),
eq_comm, ← inv_smul_eq_iff] at h
refine h ▸ smul_mem _ _ (span_subset_span R Rₛ _ ?_)
rw [← LinearMap.coe_restrictScalars R, ← LinearMap.map_span, hv]
exact mem_map_of_mem mem_top | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | span_eq_top_of_isLocalizedModule | null |
LinearIndependent.of_isLocalizedModule {ι : Type*} {v : ι → M}
(hv : LinearIndependent R v) : LinearIndependent Rₛ (f ∘ v) := by
rw [linearIndependent_iff'ₛ] at hv ⊢
intro t g₁ g₂ eq i hi
choose! a fg hfg using IsLocalization.exist_integer_multiples S (t.disjSum t) (Sum.elim g₁ g₂)
simp_rw [Sum.forall, Finset.inl_mem_disjSum, Sum.elim_inl, Finset.inr_mem_disjSum, Sum.elim_inr,
Subtype.forall'] at hfg
apply_fun ((a : R) • ·) at eq
simp_rw [← t.sum_coe_sort, Finset.smul_sum, ← smul_assoc, ← hfg,
algebraMap_smul, Function.comp_def, ← map_smul, ← map_sum,
t.sum_coe_sort (f := fun x ↦ fg (Sum.inl x) • v x),
t.sum_coe_sort (f := fun x ↦ fg (Sum.inr x) • v x)] at eq
have ⟨s, eq⟩ := IsLocalizedModule.exists_of_eq (S := S) eq
simp_rw [Finset.smul_sum, Submonoid.smul_def, smul_smul] at eq
have := congr(algebraMap R Rₛ $(hv t _ _ eq i hi))
simpa only [map_mul, (IsLocalization.map_units Rₛ s).mul_right_inj, hfg.1 ⟨i, hi⟩, hfg.2 ⟨i, hi⟩,
Algebra.smul_def, (IsLocalization.map_units Rₛ a).mul_right_inj] using this | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | LinearIndependent.of_isLocalizedModule | null |
LinearIndependent.of_isLocalizedModule_of_isRegular {ι : Type*} {v : ι → M}
(hv : LinearIndependent R v) (h : ∀ s : S, IsRegular (s : R)) : LinearIndependent R (f ∘ v) :=
hv.map_injOn _ <| by
rw [← Finsupp.range_linearCombination]
rintro _ ⟨_, r, rfl⟩ _ ⟨_, r', rfl⟩ eq
congr; ext i
have ⟨s, eq⟩ := IsLocalizedModule.exists_of_eq (S := S) eq
simp_rw [Submonoid.smul_def, ← map_smul] at eq
exact (h s).1 (DFunLike.congr_fun (hv eq) i) | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | LinearIndependent.of_isLocalizedModule_of_isRegular | null |
LinearIndependent.localization [Module Rₛ M] [IsScalarTower R Rₛ M]
{ι : Type*} {b : ι → M} (hli : LinearIndependent R b) :
LinearIndependent Rₛ b := by
have := isLocalizedModule_id S M Rₛ
exact hli.of_isLocalizedModule Rₛ S .id
include f in | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | LinearIndependent.localization | null |
IsLocalizedModule.linearIndependent_lift {ι} {v : ι → Mₛ} (hf : LinearIndependent R v) :
∃ w : ι → M, LinearIndependent R w := by
cases isEmpty_or_nonempty ι
· exact ⟨isEmptyElim, linearIndependent_empty_type⟩
have inj := hf.smul_left_injective (Classical.arbitrary ι)
choose sec hsec using surj S f
use fun i ↦ (sec (v i)).1
rw [linearIndependent_iff'ₛ] at hf ⊢
intro t g g' eq i hit
refine (isRegular_of_smul_left_injective f inj (sec (v i)).2).2 <|
hf t (fun i ↦ _ * (sec (v i)).2) (fun i ↦ _ * (sec (v i)).2) ?_ i hit
simp_rw [mul_smul, ← Submonoid.smul_def, hsec, ← map_smul, ← map_sum, eq] | lemma | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | IsLocalizedModule.linearIndependent_lift | null |
noncomputable ofIsLocalizedModule : Basis ι Rₛ Mₛ :=
.mk (b.linearIndependent.of_isLocalizedModule Rₛ S f) <| by
rw [Set.range_comp, span_eq_top_of_isLocalizedModule Rₛ S _ b.span_eq]
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | ofIsLocalizedModule | If `M` has an `R`-basis, then localizing `M` at `S` has a basis over `R` localized at `S`. |
ofIsLocalizedModule_apply (i : ι) : b.ofIsLocalizedModule Rₛ S f i = f (b i) := by
rw [ofIsLocalizedModule, coe_mk, Function.comp_apply]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | ofIsLocalizedModule_apply | null |
ofIsLocalizedModule_repr_apply (m : M) (i : ι) :
((b.ofIsLocalizedModule Rₛ S f).repr (f m)) i = algebraMap R Rₛ (b.repr m i) := by
suffices ((b.ofIsLocalizedModule Rₛ S f).repr.toLinearMap.restrictScalars R) ∘ₗ f =
Finsupp.mapRange.linearMap (Algebra.linearMap R Rₛ) ∘ₗ b.repr.toLinearMap by
exact DFunLike.congr_fun (LinearMap.congr_fun this m) i
refine ext b fun i ↦ ?_
rw [LinearMap.coe_comp, Function.comp_apply, LinearMap.coe_restrictScalars,
LinearEquiv.coe_coe, ← b.ofIsLocalizedModule_apply Rₛ S f, repr_self, LinearMap.coe_comp,
Function.comp_apply, LinearEquiv.coe_coe, repr_self, Finsupp.mapRange.linearMap_apply,
Finsupp.mapRange_single, Algebra.linearMap_apply, map_one] | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | ofIsLocalizedModule_repr_apply | null |
ofIsLocalizedModule_span :
span R (Set.range (b.ofIsLocalizedModule Rₛ S f)) = LinearMap.range f := by
calc span R (Set.range (b.ofIsLocalizedModule Rₛ S f))
_ = span R (f '' (Set.range b)) := by congr; ext; simp
_ = map f (span R (Set.range b)) := by rw [Submodule.map_span]
_ = LinearMap.range f := by rw [b.span_eq, Submodule.map_top] | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | ofIsLocalizedModule_span | null |
LinearIndependent.localization_localization {ι : Type*} {v : ι → A}
(hv : LinearIndependent R v) : LinearIndependent Rₛ (algebraMap A Aₛ ∘ v) :=
hv.of_isLocalizedModule Rₛ S (IsScalarTower.toAlgHom R A Aₛ).toLinearMap | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | LinearIndependent.localization_localization | null |
span_eq_top_localization_localization {v : Set A} (hv : span R v = ⊤) :
span Rₛ (algebraMap A Aₛ '' v) = ⊤ :=
span_eq_top_of_isLocalizedModule Rₛ S (IsScalarTower.toAlgHom R A Aₛ).toLinearMap hv | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | span_eq_top_localization_localization | null |
noncomputable localizationLocalization {ι : Type*} (b : Basis ι R A) : Basis ι Rₛ Aₛ :=
b.ofIsLocalizedModule Rₛ S (IsScalarTower.toAlgHom R A Aₛ).toLinearMap
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | localizationLocalization | If `A` has an `R`-basis, then localizing `A` at `S` has a basis over `R` localized at `S`.
A suitable instance for `[Algebra A Aₛ]` is `localizationAlgebra`. |
localizationLocalization_apply {ι : Type*} (b : Basis ι R A) (i) :
b.localizationLocalization Rₛ S Aₛ i = algebraMap A Aₛ (b i) :=
b.ofIsLocalizedModule_apply Rₛ S _ i
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | localizationLocalization_apply | null |
localizationLocalization_repr_algebraMap {ι : Type*} (b : Basis ι R A) (x i) :
(b.localizationLocalization Rₛ S Aₛ).repr (algebraMap A Aₛ x) i =
algebraMap R Rₛ (b.repr x i) := b.ofIsLocalizedModule_repr_apply Rₛ S _ _ i | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | localizationLocalization_repr_algebraMap | null |
localizationLocalization_span {ι : Type*} (b : Basis ι R A) :
Submodule.span R (Set.range (b.localizationLocalization Rₛ S Aₛ)) =
LinearMap.range (IsScalarTower.toAlgHom R A Aₛ) := b.ofIsLocalizedModule_span Rₛ S _ | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | localizationLocalization_span | null |
LinearIndependent.iff_fractionRing {ι : Type*} {b : ι → V} :
LinearIndependent R b ↔ LinearIndependent K b :=
⟨.localization K R⁰,
.restrict_scalars <| (faithfulSMul_iff_injective_smul_one ..).mp inferInstance⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | LinearIndependent.iff_fractionRing | null |
LinearMap.extendScalarsOfIsLocalization (f : M →ₗ[R] N) : M →ₗ[A] N where
toFun := f
map_add' := f.map_add
map_smul' := (IsLocalization.linearMap_compatibleSMul S A M N).map_smul _
@[simp] lemma LinearMap.restrictScalars_extendScalarsOfIsLocalization (f : M →ₗ[R] N) :
(f.extendScalarsOfIsLocalization S A).restrictScalars R = f := rfl
@[simp] lemma LinearMap.extendScalarsOfIsLocalization_apply (f : M →ₗ[A] N) :
f.extendScalarsOfIsLocalization S A = f := rfl
@[simp] lemma LinearMap.extendScalarsOfIsLocalization_apply' (f : M →ₗ[R] N) (x : M) :
(f.extendScalarsOfIsLocalization S A) x = f x := rfl | def | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | LinearMap.extendScalarsOfIsLocalization | An `R`-linear map between two `S⁻¹R`-modules is actually `S⁻¹R`-linear. |
@[simps]
LinearMap.extendScalarsOfIsLocalizationEquiv : (M →ₗ[R] N) ≃ₗ[A] (M →ₗ[A] N) where
toFun := LinearMap.extendScalarsOfIsLocalization S A
invFun := LinearMap.restrictScalars R
map_add' := by intros; ext; simp
map_smul' := by intros; ext; simp
left_inv := by intro _; ext; simp
right_inv := by intro _; ext; simp | def | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | LinearMap.extendScalarsOfIsLocalizationEquiv | The `S⁻¹R`-linear maps between two `S⁻¹R`-modules are exactly the `R`-linear maps. |
@[simps!]
LinearEquiv.extendScalarsOfIsLocalization (f : M ≃ₗ[R] N) : M ≃ₗ[A] N :=
.ofLinear (LinearMap.extendScalarsOfIsLocalization S A f)
(LinearMap.extendScalarsOfIsLocalization S A f.symm)
(by ext; simp) (by ext; simp) | def | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | LinearEquiv.extendScalarsOfIsLocalization | An `R`-linear isomorphism between `S⁻¹R`-modules is actually `S⁻¹R`-linear. |
@[simps]
LinearEquiv.extendScalarsOfIsLocalizationEquiv : (M ≃ₗ[R] N) ≃ M ≃ₗ[A] N where
toFun e := e.extendScalarsOfIsLocalization S A
invFun e := e.restrictScalars R
left_inv e := by ext; simp
right_inv e := by ext; simp | def | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | LinearEquiv.extendScalarsOfIsLocalizationEquiv | The `S⁻¹R`-linear isomorphisms between two `S⁻¹R`-modules are exactly the `R`-linear
isomorphisms. |
@[simps!]
noncomputable
mapExtendScalars : (M →ₗ[R] N) →ₗ[R] (M' →ₗ[Rₛ] N') :=
((LinearMap.extendScalarsOfIsLocalizationEquiv S Rₛ).restrictScalars R).toLinearMap ∘ₗ map S f g | def | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | mapExtendScalars | A linear map `M →ₗ[R] N` gives a map between localized modules `Mₛ →ₗ[Rₛ] Nₛ`. |
@[simps!]
noncomputable
mapEquiv (e : M ≃ₗ[R] N) : M' ≃ₗ[Rₛ] N' :=
LinearEquiv.ofLinear
(IsLocalizedModule.mapExtendScalars S f g Rₛ e)
(IsLocalizedModule.mapExtendScalars S g f Rₛ e.symm)
(by
apply LinearMap.restrictScalars_injective R
apply IsLocalizedModule.linearMap_ext S g g
ext; simp)
(by
apply LinearMap.restrictScalars_injective R
apply IsLocalizedModule.linearMap_ext S f f
ext; simp) | def | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | mapEquiv | An `R`-module isomorphism `M ≃ₗ[R] N` gives an `Rₛ`-module isomorphism `Mₛ ≃ₗ[Rₛ] Nₛ`. |
noncomputable
LocalizedModule.map :
(M →ₗ[R] N) →ₗ[R] (LocalizedModule S M →ₗ[Localization S] LocalizedModule S N) :=
IsLocalizedModule.mapExtendScalars S (LocalizedModule.mkLinearMap S M)
(LocalizedModule.mkLinearMap S N) (Localization S)
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | LocalizedModule.map | A linear map `M →ₗ[R] N` gives a map between localized modules `Mₛ →ₗ[Rₛ] Nₛ`. |
LocalizedModule.map_mk (f : M →ₗ[R] N) (x y) :
map S f (.mk x y) = LocalizedModule.mk (f x) y := by
rw [IsLocalizedModule.mk_eq_mk', IsLocalizedModule.mk_eq_mk']
exact IsLocalizedModule.map_mk' _ _ _ _ _ _
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | LocalizedModule.map_mk | null |
LocalizedModule.map_id :
LocalizedModule.map S (.id (R := R) (M := M)) = LinearMap.id :=
LinearMap.ext fun x ↦ LinearMap.congr_fun (IsLocalizedModule.map_id S (mkLinearMap S M)) x | lemma | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | LocalizedModule.map_id | null |
LocalizedModule.map_injective (l : M →ₗ[R] N) (hl : Function.Injective l) :
Function.Injective (map S l) :=
IsLocalizedModule.map_injective S (mkLinearMap S M) (mkLinearMap S N) l hl | lemma | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | LocalizedModule.map_injective | null |
LocalizedModule.map_surjective (l : M →ₗ[R] N) (hl : Function.Surjective l) :
Function.Surjective (map S l) :=
IsLocalizedModule.map_surjective S (mkLinearMap S M) (mkLinearMap S N) l hl | lemma | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | LocalizedModule.map_surjective | null |
LocalizedModule.restrictScalars_map_eq {M' N' : Type*} [AddCommMonoid M'] [AddCommMonoid N']
[Module R M'] [Module R N'] (g₁ : M →ₗ[R] M') (g₂ : N →ₗ[R] N')
[IsLocalizedModule S g₁] [IsLocalizedModule S g₂]
(l : M →ₗ[R] N) :
(map S l).restrictScalars R = (IsLocalizedModule.iso S g₂).symm ∘ₗ
IsLocalizedModule.map S g₁ g₂ l ∘ₗ IsLocalizedModule.iso S g₁ := by
rw [LinearEquiv.eq_toLinearMap_symm_comp, ← LinearEquiv.comp_toLinearMap_symm_eq]
apply IsLocalizedModule.linearMap_ext S g₁ g₂
rw [LinearMap.comp_assoc, IsLocalizedModule.iso_symm_comp]
ext
simp | lemma | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.LinearAlgebra.Basis.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer"
] | Mathlib/RingTheory/Localization/Module.lean | LocalizedModule.restrictScalars_map_eq | null |
Algebra.map_leftMulMatrix_localization {ι : Type*} [Fintype ι] [DecidableEq ι]
(b : Basis ι R S) (a : S) :
(algebraMap R Rₘ).mapMatrix (leftMulMatrix b a) =
leftMulMatrix (b.localizationLocalization Rₘ M Sₘ) (algebraMap S Sₘ a) := by
ext i j
simp only [Matrix.map_apply, RingHom.mapMatrix_apply, leftMulMatrix_eq_repr_mul, ← map_mul,
Basis.localizationLocalization_apply, Basis.localizationLocalization_repr_algebraMap] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Module",
"Mathlib.RingTheory.Norm.Basic",
"Mathlib.RingTheory.Discriminant"
] | Mathlib/RingTheory/Localization/NormTrace.lean | Algebra.map_leftMulMatrix_localization | null |
Algebra.norm_localization [Module.Free R S] [Module.Finite R S] (a : S) :
Algebra.norm Rₘ (algebraMap S Sₘ a) = algebraMap R Rₘ (Algebra.norm R a) := by
cases subsingleton_or_nontrivial R
· haveI : Subsingleton Rₘ := Module.subsingleton R Rₘ
simp [eq_iff_true_of_subsingleton]
let b := Module.Free.chooseBasis R S
letI := Classical.decEq (Module.Free.ChooseBasisIndex R S)
rw [Algebra.norm_eq_matrix_det (b.localizationLocalization Rₘ M Sₘ),
Algebra.norm_eq_matrix_det b, RingHom.map_det, ← Algebra.map_leftMulMatrix_localization]
variable {M} in | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Module",
"Mathlib.RingTheory.Norm.Basic",
"Mathlib.RingTheory.Discriminant"
] | Mathlib/RingTheory/Localization/NormTrace.lean | Algebra.norm_localization | Let `S` be an extension of `R` and `Rₘ Sₘ` be localizations at `M` of `R S` respectively.
Then the norm of `a : Sₘ` over `Rₘ` is the norm of `a : S` over `R` if `S` is free as `R`-module. |
Algebra.norm_eq_iff [Module.Free R S] [Module.Finite R S] {a : S} {b : R}
(hM : M ≤ nonZeroDivisors R) : Algebra.norm R a = b ↔
(Algebra.norm Rₘ) ((algebraMap S Sₘ) a) = algebraMap R Rₘ b :=
⟨fun h ↦ h.symm ▸ Algebra.norm_localization _ M _, fun h ↦
IsLocalization.injective Rₘ hM <| h.symm ▸ (Algebra.norm_localization R M a).symm⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.Module",
"Mathlib.RingTheory.Norm.Basic",
"Mathlib.RingTheory.Discriminant"
] | Mathlib/RingTheory/Localization/NormTrace.lean | Algebra.norm_eq_iff | The norm of `a : S` in `R` can be computed in `Sₘ`. |
Algebra.trace_localization [Module.Free R S] [Module.Finite R S] (a : S) :
Algebra.trace Rₘ Sₘ (algebraMap S Sₘ a) = algebraMap R Rₘ (Algebra.trace R S a) := by
cases subsingleton_or_nontrivial R
· haveI : Subsingleton Rₘ := Module.subsingleton R Rₘ
simp [eq_iff_true_of_subsingleton]
let b := Module.Free.chooseBasis R S
letI := Classical.decEq (Module.Free.ChooseBasisIndex R S)
rw [Algebra.trace_eq_matrix_trace (b.localizationLocalization Rₘ M Sₘ),
Algebra.trace_eq_matrix_trace b, ← Algebra.map_leftMulMatrix_localization]
exact (AddMonoidHom.map_trace (algebraMap R Rₘ).toAddMonoidHom _).symm | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Module",
"Mathlib.RingTheory.Norm.Basic",
"Mathlib.RingTheory.Discriminant"
] | Mathlib/RingTheory/Localization/NormTrace.lean | Algebra.trace_localization | Let `S` be an extension of `R` and `Rₘ Sₘ` be localizations at `M` of `R S` respectively.
Then the trace of `a : Sₘ` over `Rₘ` is the trace of `a : S` over `R` if `S` is free as `R`-module. |
Algebra.traceMatrix_localizationLocalization (b : Basis ι R S) :
Algebra.traceMatrix Rₘ (b.localizationLocalization Rₘ M Sₘ) =
(algebraMap R Rₘ).mapMatrix (Algebra.traceMatrix R b) := by
have : Module.Finite R S := Module.Finite.of_basis b
have : Module.Free R S := Module.Free.of_basis b
ext i j : 2
simp_rw [RingHom.mapMatrix_apply, Matrix.map_apply, traceMatrix_apply, traceForm_apply,
Basis.localizationLocalization_apply, ← map_mul]
exact Algebra.trace_localization R M _ | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Module",
"Mathlib.RingTheory.Norm.Basic",
"Mathlib.RingTheory.Discriminant"
] | Mathlib/RingTheory/Localization/NormTrace.lean | Algebra.traceMatrix_localizationLocalization | null |
Algebra.discr_localizationLocalization (b : Basis ι R S) :
Algebra.discr Rₘ (b.localizationLocalization Rₘ M Sₘ) =
algebraMap R Rₘ (Algebra.discr R b) := by
rw [Algebra.discr_def, Algebra.discr_def, RingHom.map_det,
Algebra.traceMatrix_localizationLocalization] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Module",
"Mathlib.RingTheory.Norm.Basic",
"Mathlib.RingTheory.Discriminant"
] | Mathlib/RingTheory/Localization/NormTrace.lean | Algebra.discr_localizationLocalization | Let `S` be an extension of `R` and `Rₘ Sₘ` be localizations at `M` of `R S` respectively. Let
`b` be a `R`-basis of `S`. Then discriminant of the `Rₘ`-basis of `Sₘ` induced by `b` is the
discriminant of `b`. |
exists_reduced_fraction (x : K) :
∃ (a : A) (b : nonZeroDivisors A), IsRelPrime a b ∧ mk' K a b = x := by
obtain ⟨⟨b, b_nonzero⟩, a, hab⟩ := exists_integer_multiple (nonZeroDivisors A) x
obtain ⟨a', b', c', no_factor, rfl, rfl⟩ :=
UniqueFactorizationMonoid.exists_reduced_factors' a b
(mem_nonZeroDivisors_iff_ne_zero.mp b_nonzero)
obtain ⟨_, b'_nonzero⟩ := mul_mem_nonZeroDivisors.mp b_nonzero
refine ⟨a', ⟨b', b'_nonzero⟩, no_factor, ?_⟩
refine mul_left_cancel₀ (IsFractionRing.to_map_ne_zero_of_mem_nonZeroDivisors b_nonzero) ?_
simp only [RingHom.map_mul, Algebra.smul_def] at *
rw [← hab, mul_assoc, mk'_spec' _ a' ⟨b', b'_nonzero⟩] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.UniqueFactorizationDomain.GCDMonoid"
] | Mathlib/RingTheory/Localization/NumDen.lean | exists_reduced_fraction | null |
noncomputable num (x : K) : A :=
Classical.choose (exists_reduced_fraction A x) | def | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.UniqueFactorizationDomain.GCDMonoid"
] | Mathlib/RingTheory/Localization/NumDen.lean | num | `f.num x` is the numerator of `x : f.codomain` as a reduced fraction. |
noncomputable den (x : K) : nonZeroDivisors A :=
Classical.choose (Classical.choose_spec (exists_reduced_fraction A x)) | def | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.UniqueFactorizationDomain.GCDMonoid"
] | Mathlib/RingTheory/Localization/NumDen.lean | den | `f.den x` is the denominator of `x : f.codomain` as a reduced fraction. |
num_den_reduced (x : K) : IsRelPrime (num A x) (den A x) :=
(Classical.choose_spec (Classical.choose_spec (exists_reduced_fraction A x))).1 | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.UniqueFactorizationDomain.GCDMonoid"
] | Mathlib/RingTheory/Localization/NumDen.lean | num_den_reduced | null |
mk'_num_den (x : K) : mk' K (num A x) (den A x) = x :=
(Classical.choose_spec (Classical.choose_spec (exists_reduced_fraction A x))).2
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.UniqueFactorizationDomain.GCDMonoid"
] | Mathlib/RingTheory/Localization/NumDen.lean | mk'_num_den | null |
mk'_num_den' (x : K) : algebraMap A K (num A x) / algebraMap A K (den A x) = x := by
rw [← mk'_eq_div]
apply mk'_num_den
variable {A} | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.UniqueFactorizationDomain.GCDMonoid"
] | Mathlib/RingTheory/Localization/NumDen.lean | mk'_num_den' | null |
num_mul_den_eq_num_iff_eq {x y : K} :
x * algebraMap A K (den A y) = algebraMap A K (num A y) ↔ x = y :=
⟨fun h => by simpa only [mk'_num_den] using eq_mk'_iff_mul_eq.mpr h, fun h ↦
eq_mk'_iff_mul_eq.mp (by rw [h, mk'_num_den])⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.UniqueFactorizationDomain.GCDMonoid"
] | Mathlib/RingTheory/Localization/NumDen.lean | num_mul_den_eq_num_iff_eq | null |
num_mul_den_eq_num_iff_eq' {x y : K} :
y * algebraMap A K (den A x) = algebraMap A K (num A x) ↔ x = y :=
⟨fun h ↦ by simpa only [eq_comm, mk'_num_den] using eq_mk'_iff_mul_eq.mpr h, fun h ↦
eq_mk'_iff_mul_eq.mp (by rw [h, mk'_num_den])⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.UniqueFactorizationDomain.GCDMonoid"
] | Mathlib/RingTheory/Localization/NumDen.lean | num_mul_den_eq_num_iff_eq' | null |
num_mul_den_eq_num_mul_den_iff_eq {x y : K} :
num A y * den A x = num A x * den A y ↔ x = y :=
⟨fun h ↦ by simpa only [mk'_num_den] using mk'_eq_of_eq' (S := K) h, fun h ↦ by rw [h]⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.UniqueFactorizationDomain.GCDMonoid"
] | Mathlib/RingTheory/Localization/NumDen.lean | num_mul_den_eq_num_mul_den_iff_eq | null |
eq_zero_of_num_eq_zero {x : K} (h : num A x = 0) : x = 0 :=
(num_mul_den_eq_num_iff_eq' (A := A)).mp (by rw [zero_mul, h, RingHom.map_zero])
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.UniqueFactorizationDomain.GCDMonoid"
] | Mathlib/RingTheory/Localization/NumDen.lean | eq_zero_of_num_eq_zero | null |
num_zero : IsFractionRing.num A (0 : K) = 0 := by
have := mk'_num_den' A (0 : K)
simp only [div_eq_zero_iff] at this
rcases this with h | h
· exact FaithfulSMul.algebraMap_injective A K (by convert h; simp)
· replace h : algebraMap A K (den A (0 : K)) = algebraMap A K 0 := by convert h; simp
absurd FaithfulSMul.algebraMap_injective A K h
apply nonZeroDivisors.coe_ne_zero
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.UniqueFactorizationDomain.GCDMonoid"
] | Mathlib/RingTheory/Localization/NumDen.lean | num_zero | null |
num_eq_zero (x : K) : IsFractionRing.num A x = 0 ↔ x = 0 :=
⟨eq_zero_of_num_eq_zero, fun h ↦ h ▸ num_zero⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.UniqueFactorizationDomain.GCDMonoid"
] | Mathlib/RingTheory/Localization/NumDen.lean | num_eq_zero | null |
isInteger_of_isUnit_den {x : K} (h : IsUnit (den A x : A)) : IsInteger A x := by
obtain ⟨d, hd⟩ := h
have d_ne_zero : algebraMap A K (den A x) ≠ 0 :=
IsFractionRing.to_map_ne_zero_of_mem_nonZeroDivisors (den A x).2
use ↑d⁻¹ * num A x
refine _root_.trans ?_ (mk'_num_den A x)
rw [map_mul, map_units_inv, hd]
apply mul_left_cancel₀ d_ne_zero
rw [← mul_assoc, mul_inv_cancel₀ d_ne_zero, one_mul, mk'_spec'] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.UniqueFactorizationDomain.GCDMonoid"
] | Mathlib/RingTheory/Localization/NumDen.lean | isInteger_of_isUnit_den | null |
isUnit_den_iff (x : K) : IsUnit (den A x : A) ↔ IsLocalization.IsInteger A x where
mp := isInteger_of_isUnit_den
mpr h := by
have ⟨v, h⟩ := h
apply IsRelPrime.isUnit_of_dvd (num_den_reduced A x).symm
use v
apply_fun algebraMap A K
· simp only [map_mul, h]
rw [mul_comm, ← div_eq_iff]
· simp only [mk'_num_den']
intro h
replace h : algebraMap A K (den A x : A) = algebraMap A K 0 := by convert h; simp
exact nonZeroDivisors.coe_ne_zero _ <| FaithfulSMul.algebraMap_injective A K h
exact FaithfulSMul.algebraMap_injective A K | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.UniqueFactorizationDomain.GCDMonoid"
] | Mathlib/RingTheory/Localization/NumDen.lean | isUnit_den_iff | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.