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 ⌀ |
|---|---|---|---|---|---|---|
of_localizationSpan (t : Set R) (ht : Ideal.span t = ⊤)
(H : ∀ (g : t), Module.Finite (Localization.Away g.val)
(LocalizedModule (Submonoid.powers g.val) M)) :
Module.Finite R M :=
let f (g : t) : M →ₗ[R] LocalizedModule (Submonoid.powers g.val) M :=
LocalizedModule.mkLinearMap (Submonoid.powers g.val) M
of_localizationSpan' t ht f H | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Int",
"Mathlib.RingTheory.Localization.Algebra",
"Mathlib.RingTheory.RingHom.Finite"
] | Mathlib/RingTheory/Localization/Finiteness.lean | of_localizationSpan | If there exists a set `{ r }` of `R` such that `Mᵣ` is `Rᵣ`-finite for each `r`,
then `M` is a finite `R`-module. |
fg_of_localizationSpan {I : Ideal R} (t : Set R) (ht : Ideal.span t = ⊤)
(H : ∀ (g : t), (I.map (algebraMap R (Localization.Away g.val))).FG) : I.FG := by
apply Module.Finite.iff_fg.mp
let k (g : t) : I →ₗ[R] (I.map (algebraMap R (Localization.Away g.val))) :=
Algebra.idealMap I (S := Localization.Away g.val)
exact Module.Finite.of_localizationSpan' t ht k (fun g ↦ Module.Finite.iff_fg.mpr (H g)) | lemma | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Int",
"Mathlib.RingTheory.Localization.Algebra",
"Mathlib.RingTheory.RingHom.Finite"
] | Mathlib/RingTheory/Localization/Finiteness.lean | fg_of_localizationSpan | If `I` is an ideal such that there exists a set `{ r }` of `R` such
that the image of `I` in `Rᵣ` is finitely generated for each `r`, then `I` is finitely
generated. |
RingHom.ker_fg_of_localizationSpan (t : Set R) (ht : Ideal.span t = ⊤)
(H : ∀ g : t, (RingHom.ker (Localization.awayMap f g.val)).FG) :
(RingHom.ker f).FG := by
apply Ideal.fg_of_localizationSpan t ht
intro g
rw [← IsLocalization.ker_map (Localization.Away (f g.val)) f (Submonoid.map_powers f g.val)]
exact H g | lemma | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Int",
"Mathlib.RingTheory.Localization.Algebra",
"Mathlib.RingTheory.RingHom.Finite"
] | Mathlib/RingTheory/Localization/Finiteness.lean | RingHom.ker_fg_of_localizationSpan | To check that the kernel of a ring homomorphism is finitely generated,
it suffices to check this after localizing at a spanning set of the source. |
IsFractionRing (R : Type*) [CommSemiring R] (K : Type*) [CommSemiring K] [Algebra R K] :=
IsLocalization (nonZeroDivisors R) K | abbrev | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | IsFractionRing | `IsFractionRing R K` states `K` is the ring of fractions of a commutative ring `R`. |
Rat.isFractionRing : IsFractionRing ℤ ℚ where
map_units := by
rintro ⟨x, hx⟩
rw [mem_nonZeroDivisors_iff_ne_zero] at hx
simpa only [eq_intCast, isUnit_iff_ne_zero, Int.cast_eq_zero, Ne, Subtype.coe_mk] using hx
surj := by
rintro ⟨n, d, hd, h⟩
refine ⟨⟨n, ⟨d, ?_⟩⟩, Rat.mul_den_eq_num _⟩
rw [mem_nonZeroDivisors_iff_ne_zero, Int.natCast_ne_zero_iff_pos]
exact Nat.zero_lt_of_ne_zero hd
exists_of_eq {x y} := by
rw [eq_intCast, eq_intCast, Int.cast_inj]
rintro rfl
use 1 | instance | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | Rat.isFractionRing | The cast from `Int` to `Rat` as a `FractionRing`. |
NNRat.isFractionRing : IsFractionRing ℕ ℚ≥0 where
map_units y := by simp
surj z := ⟨⟨z.num, ⟨z.den, by simp⟩⟩, by simp⟩
exists_of_eq {x y} h := ⟨1, by simpa using h⟩ | instance | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | NNRat.isFractionRing | As a corollary, `Rat` is also a localization at only positive integers. -/
instance : IsLocalization (Submonoid.pos ℤ) ℚ where
map_units y := by simpa using y.prop.ne'
surj z := by
obtain ⟨⟨x1, x2⟩, hx⟩ := IsLocalization.surj (nonZeroDivisors ℤ) z
obtain hx2 | hx2 := lt_or_gt_of_ne (show x2.val ≠ 0 by simp)
· exact ⟨⟨-x1, ⟨-x2.val, by simpa using hx2⟩⟩, by simpa using hx⟩
· exact ⟨⟨x1, ⟨x2.val, hx2⟩⟩, hx⟩
exists_of_eq {x y} h := ⟨1, by simpa using Rat.intCast_inj.mp h⟩
/-- `NNRat` is the ring of fractions of `Nat`. |
of_field [Field K] [Algebra R K] [FaithfulSMul R K]
(surj : ∀ z : K, ∃ x y, z = algebraMap R K x / algebraMap R K y) :
IsFractionRing R K :=
have inj := FaithfulSMul.algebraMap_injective R K
have := inj.noZeroDivisors _ (map_zero _) (map_mul _)
have := Module.nontrivial R K
{ map_units x :=
.mk0 _ <| (map_ne_zero_iff _ inj).mpr <| mem_nonZeroDivisors_iff_ne_zero.mp x.2
surj z := by
have ⟨x, y, eq⟩ := surj z
obtain rfl | hy := eq_or_ne y 0
· obtain rfl : z = 0 := by simpa using eq
exact ⟨(0, 1), by simp⟩
exact ⟨⟨x, y, mem_nonZeroDivisors_iff_ne_zero.mpr hy⟩,
(eq_div_iff_mul_eq <| (map_ne_zero_iff _ inj).mpr hy).mp eq⟩
exists_of_eq eq := ⟨1, by simpa using inj eq⟩ }
variable {R K} | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | of_field | null |
to_map_eq_zero_iff {x : R} : algebraMap R K x = 0 ↔ x = 0 :=
IsLocalization.to_map_eq_zero_iff _ le_rfl
variable (R K) | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | to_map_eq_zero_iff | null |
protected injective : Function.Injective (algebraMap R K) :=
IsLocalization.injective _ (le_of_eq rfl) | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | injective | null |
@[norm_cast, simp]
coe_inj {a b : R} : (↑a : K) = ↑b ↔ a = b :=
(IsFractionRing.injective R K).eq_iff | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | coe_inj | null |
protected to_map_ne_zero_of_mem_nonZeroDivisors [Nontrivial R] {x : R}
(hx : x ∈ nonZeroDivisors R) : algebraMap R K x ≠ 0 :=
IsLocalization.to_map_ne_zero_of_mem_nonZeroDivisors _ le_rfl hx
variable (A) [IsDomain A]
include A in | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | to_map_ne_zero_of_mem_nonZeroDivisors | null |
protected isDomain : IsDomain K :=
isDomain_of_le_nonZeroDivisors _ (le_refl (nonZeroDivisors A)) | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | isDomain | A `CommRing` `K` which is the localization of an integral domain `R` at `R - {0}` is an
integral domain. |
@[stacks 09FJ]
noncomputable toField : Field K where
__ := IsFractionRing.isDomain A
inv := IsFractionRing.inv A
mul_inv_cancel := IsFractionRing.mul_inv_cancel A
inv_zero := show IsFractionRing.inv A (0 : K) = 0 by rw [IsFractionRing.inv]; exact dif_pos rfl
nnqsmul := _
nnqsmul_def := fun _ _ => rfl
qsmul := _
qsmul_def := fun _ _ => rfl | abbrev | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | toField | The inverse of an element in the field of fractions of an integral domain. -/
protected noncomputable irreducible_def inv (z : K) : K := open scoped Classical in
if h : z = 0 then 0
else
mk' K ↑(sec (nonZeroDivisors A) z).2
⟨(sec _ z).1,
mem_nonZeroDivisors_iff_ne_zero.2 fun h0 =>
h <| eq_zero_of_fst_eq_zero (sec_spec (nonZeroDivisors A) z) h0⟩
protected theorem mul_inv_cancel (x : K) (hx : x ≠ 0) : x * IsFractionRing.inv A x = 1 := by
rw [IsFractionRing.inv, dif_neg hx, ←
IsUnit.mul_left_inj
(map_units K
⟨(sec _ x).1,
mem_nonZeroDivisors_iff_ne_zero.2 fun h0 =>
hx <| eq_zero_of_fst_eq_zero (sec_spec (nonZeroDivisors A) x) h0⟩),
one_mul, mul_assoc]
rw [mk'_spec, ← eq_mk'_iff_mul_eq]
exact (mk'_sec _ x).symm
/-- A `CommRing` `K` which is the localization of an integral domain `R` at `R - {0}` is a field.
See note [reducible non-instances]. |
surjective_iff_isField [IsDomain R] : Function.Surjective (algebraMap R K) ↔ IsField R where
mp h := (RingEquiv.ofBijective (algebraMap R K)
⟨IsFractionRing.injective R K, h⟩).toMulEquiv.isField (IsFractionRing.toField R).toIsField
mpr h :=
letI := h.toField
(IsLocalization.atUnits R _ (S := K)
(fun _ hx ↦ Ne.isUnit (mem_nonZeroDivisors_iff_ne_zero.mp hx))).surjective | lemma | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | surjective_iff_isField | null |
mk'_mk_eq_div {r s} (hs : s ∈ nonZeroDivisors A) :
mk' K r ⟨s, hs⟩ = algebraMap A K r / algebraMap A K s :=
haveI := (algebraMap A K).domain_nontrivial
mk'_eq_iff_eq_mul.2 <|
(div_mul_cancel₀ (algebraMap A K r)
(IsFractionRing.to_map_ne_zero_of_mem_nonZeroDivisors hs)).symm
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | mk'_mk_eq_div | null |
mk'_eq_div {r} (s : nonZeroDivisors A) : mk' K r s = algebraMap A K r / algebraMap A K s :=
mk'_mk_eq_div s.2 | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | mk'_eq_div | null |
div_surjective (z : K) :
∃ x y : A, y ∈ nonZeroDivisors A ∧ algebraMap _ _ x / algebraMap _ _ y = z :=
let ⟨x, ⟨y, hy⟩, h⟩ := mk'_surjective (nonZeroDivisors A) z
⟨x, y, hy, by rwa [mk'_eq_div] at h⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | div_surjective | null |
isUnit_map_of_injective (hg : Function.Injective g) (y : nonZeroDivisors A) :
IsUnit (g y) :=
haveI := g.domain_nontrivial
IsUnit.mk0 (g y) <|
show g.toMonoidWithZeroHom y ≠ 0 from map_ne_zero_of_mem_nonZeroDivisors g hg y.2 | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | isUnit_map_of_injective | null |
mk'_eq_zero_iff_eq_zero [Algebra R K] [IsFractionRing R K] {x : R} {y : nonZeroDivisors R} :
mk' K x y = 0 ↔ x = 0 := by
haveI := (algebraMap R K).domain_nontrivial
simp [nonZeroDivisors.ne_zero] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | mk'_eq_zero_iff_eq_zero | null |
mk'_eq_one_iff_eq {x : A} {y : nonZeroDivisors A} : mk' K x y = 1 ↔ x = y := by
haveI := (algebraMap A K).domain_nontrivial
refine ⟨?_, fun hxy => by rw [hxy, mk'_self']⟩
intro hxy
have hy : (algebraMap A K) ↑y ≠ (0 : K) :=
IsFractionRing.to_map_ne_zero_of_mem_nonZeroDivisors y.property
rw [IsFractionRing.mk'_eq_div, div_eq_one_iff_eq hy] at hxy
exact IsFractionRing.injective A K hxy | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | mk'_eq_one_iff_eq | null |
algHom_commutes (e : K₁ →ₐ[A] K₂) (f : L₁ →ₐ[B] L₂) (x : K₁) :
algebraMap K₂ L₂ (e x) = f (algebraMap K₁ L₁ x) := by
obtain ⟨r, s, hs, rfl⟩ := IsFractionRing.div_surjective (A := A) x
simp_rw [map_div₀, AlgHom.commutes, ← IsScalarTower.algebraMap_apply,
IsScalarTower.algebraMap_apply A B L₁, AlgHom.commutes, ← IsScalarTower.algebraMap_apply] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | algHom_commutes | null |
algEquiv_commutes (e : K₁ ≃ₐ[A] K₂) (f : L₁ ≃ₐ[B] L₂) (x : K₁) :
algebraMap K₂ L₂ (e x) = f (algebraMap K₁ L₁ x) := by
exact algHom_commutes e.toAlgHom f.toAlgHom _ | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | algEquiv_commutes | null |
closure_range_algebraMap : Subfield.closure (Set.range (algebraMap A K)) = ⊤ :=
top_unique fun z _ ↦ by
obtain ⟨_, _, -, rfl⟩ := div_surjective (A := A) z
apply div_mem <;> exact Subfield.subset_closure ⟨_, rfl⟩
variable {L : Type*} [Field L] {g : A →+* L} {f : K →+* L} | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | closure_range_algebraMap | If `A` is a commutative ring with fraction field `K`, then the subfield of `K` generated by
the image of `algebraMap A K` is equal to the whole field `K`. |
ringHom_fieldRange_eq_of_comp_eq (h : RingHom.comp f (algebraMap A K) = g) :
f.fieldRange = Subfield.closure g.range := by
rw [f.fieldRange_eq_map, ← closure_range_algebraMap A K,
f.map_field_closure, ← Set.range_comp, ← f.coe_comp, h, g.coe_range] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | ringHom_fieldRange_eq_of_comp_eq | If `A` is a commutative ring with fraction field `K`, `L` is a field, `g : A →+* L` lifts to
`f : K →+* L`, then the image of `f` is the subfield generated by the image of `g`. |
ringHom_fieldRange_eq_of_comp_eq_of_range_eq (h : RingHom.comp f (algebraMap A K) = g)
{s : Set L} (hs : g.range = Subring.closure s) : f.fieldRange = Subfield.closure s := by
rw [ringHom_fieldRange_eq_of_comp_eq h, hs]
ext
simp_rw [Subfield.mem_closure_iff, Subring.closure_eq] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | ringHom_fieldRange_eq_of_comp_eq_of_range_eq | If `A` is a commutative ring with fraction field `K`, `L` is a field, `g : A →+* L` lifts to
`f : K →+* L`, `s` is a set such that the image of `g` is the subring generated by `s`,
then the image of `f` is the subfield generated by `s`. |
noncomputable lift (hg : Injective g) : K →+* L :=
IsLocalization.lift fun y : nonZeroDivisors A => isUnit_map_of_injective hg y | def | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | lift | Given a commutative ring `A` with field of fractions `K`,
and an injective ring hom `g : A →+* L` where `L` is a field, we get a
field hom sending `z : K` to `g x * (g y)⁻¹`, where `(x, y) : A × (NonZeroDivisors A)` are
such that `z = f x * (f y)⁻¹`. |
lift_unique (hg : Function.Injective g) {f : K →+* L}
(hf1 : ∀ x, f (algebraMap A K x) = g x) : IsFractionRing.lift hg = f :=
IsLocalization.lift_unique _ hf1 | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | lift_unique | null |
ringHom_ext {f1 f2 : K →+* L}
(hf : ∀ x : A, f1 (algebraMap A K x) = f2 (algebraMap A K x)) : f1 = f2 := by
ext z
obtain ⟨x, y, hy, rfl⟩ := IsFractionRing.div_surjective (A := A) z
rw [map_div₀, map_div₀, hf, hf] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | ringHom_ext | Another version of unique to give two lift maps should be equal |
injective_comp_algebraMap :
Function.Injective fun (f : K →+* L) => f.comp (algebraMap A K) :=
fun _ _ h => ringHom_ext (fun x => RingHom.congr_fun h x) | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | injective_comp_algebraMap | null |
noncomputable liftAlgHom : K →ₐ[R] L :=
IsLocalization.liftAlgHom fun y : nonZeroDivisors A => isUnit_map_of_injective hg y | def | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | liftAlgHom | `AlgHom` version of `IsFractionRing.lift`. |
liftAlgHom_toRingHom : (liftAlgHom hg : K →ₐ[R] L).toRingHom = lift hg := rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | liftAlgHom_toRingHom | null |
coe_liftAlgHom : ⇑(liftAlgHom hg : K →ₐ[R] L) = lift hg := rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | coe_liftAlgHom | null |
liftAlgHom_apply : liftAlgHom hg x = lift hg x := rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | liftAlgHom_apply | null |
@[simp]
lift_algebraMap (hg : Injective g) (x) : lift hg (algebraMap A K x) = g x :=
lift_eq _ _ | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | lift_algebraMap | Given a commutative ring `A` with field of fractions `K`,
and an injective ring hom `g : A →+* L` where `L` is a field,
the field hom induced from `K` to `L` maps `x` to `g x` for all
`x : A`. |
lift_fieldRange (hg : Injective g) :
(lift hg : K →+* L).fieldRange = Subfield.closure g.range :=
ringHom_fieldRange_eq_of_comp_eq (by ext; simp) | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | lift_fieldRange | The image of `IsFractionRing.lift` is the subfield generated by the image
of the ring hom. |
lift_fieldRange_eq_of_range_eq (hg : Injective g)
{s : Set L} (hs : g.range = Subring.closure s) :
(lift hg : K →+* L).fieldRange = Subfield.closure s :=
ringHom_fieldRange_eq_of_comp_eq_of_range_eq (by ext; simp) hs | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | lift_fieldRange_eq_of_range_eq | The image of `IsFractionRing.lift` is the subfield generated by `s`, if the image
of the ring hom is the subring generated by `s`. |
lift_mk' (hg : Injective g) (x) (y : nonZeroDivisors A) :
lift hg (mk' K x y) = g x / g y := by simp only [mk'_eq_div, map_div₀, lift_algebraMap] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | lift_mk' | Given a commutative ring `A` with field of fractions `K`,
and an injective ring hom `g : A →+* L` where `L` is a field,
field hom induced from `K` to `L` maps `f x / f y` to `g x / g y` for all
`x : A, y ∈ NonZeroDivisors A`. |
noncomputable map {A B K L : Type*} [CommRing A] [CommRing B] [IsDomain B] [CommRing K]
[Algebra A K] [IsFractionRing A K] [CommRing L] [Algebra B L] [IsFractionRing B L] {j : A →+* B}
(hj : Injective j) : K →+* L :=
IsLocalization.map L j
(show nonZeroDivisors A ≤ (nonZeroDivisors B).comap j from
nonZeroDivisors_le_comap_nonZeroDivisors_of_injective j hj) | def | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | map | Given commutative rings `A, B` where `B` is an integral domain, with fraction rings `K`, `L`
and an injective ring hom `j : A →+* B`, we get a ring hom
sending `z : K` to `g (j x) * (g (j y))⁻¹`, where `(x, y) : A × (NonZeroDivisors A)` are
such that `z = f x * (f y)⁻¹`. |
noncomputable ringEquivOfRingEquiv : K ≃+* L :=
IsLocalization.ringEquivOfRingEquiv K L h (MulEquivClass.map_nonZeroDivisors h)
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | ringEquivOfRingEquiv | Given rings `A, B` and localization maps to their fraction rings
`f : A →+* K, g : B →+* L`, an isomorphism `h : A ≃+* B` induces an isomorphism of
fraction rings `K ≃+* L`. |
ringEquivOfRingEquiv_algebraMap
(a : A) : ringEquivOfRingEquiv h (algebraMap A K a) = algebraMap B L (h a) := by
simp [ringEquivOfRingEquiv]
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | ringEquivOfRingEquiv_algebraMap | null |
ringEquivOfRingEquiv_symm :
(ringEquivOfRingEquiv h : K ≃+* L).symm = ringEquivOfRingEquiv h.symm := rfl | lemma | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | ringEquivOfRingEquiv_symm | null |
noncomputable algEquivOfAlgEquiv : K ≃ₐ[R] L :=
IsLocalization.algEquivOfAlgEquiv K L h (MulEquivClass.map_nonZeroDivisors h)
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | algEquivOfAlgEquiv | Given `R`-algebras `A, B` and localization maps to their fraction rings
`f : A →ₐ[R] K, g : B →ₐ[R] L`, an isomorphism `h : A ≃ₐ[R] B` induces an isomorphism of
fraction rings `K ≃ₐ[R] L`. |
algEquivOfAlgEquiv_algebraMap
(a : A) : algEquivOfAlgEquiv h (algebraMap A K a) = algebraMap B L (h a) := by
simp [algEquivOfAlgEquiv]
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | algEquivOfAlgEquiv_algebraMap | null |
algEquivOfAlgEquiv_symm :
(algEquivOfAlgEquiv h : K ≃ₐ[R] L).symm = algEquivOfAlgEquiv h.symm := rfl | lemma | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | algEquivOfAlgEquiv_symm | null |
noncomputable fieldEquivOfAlgEquiv (f : B ≃ₐ[A] C) : FB ≃ₐ[FA] FC where
__ := IsFractionRing.ringEquivOfRingEquiv f.toRingEquiv
commutes' x := by
obtain ⟨x, y, -, rfl⟩ := IsFractionRing.div_surjective (A := A) x
simp_rw [map_div₀, ← IsScalarTower.algebraMap_apply, IsScalarTower.algebraMap_apply A B FB]
simp [← IsScalarTower.algebraMap_apply A C FC] | def | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | fieldEquivOfAlgEquiv | An algebra isomorphism of rings induces an algebra isomorphism of fraction fields. |
restrictScalars_fieldEquivOfAlgEquiv (f : B ≃ₐ[A] C) :
(fieldEquivOfAlgEquiv FA FB FC f).restrictScalars A = algEquivOfAlgEquiv f := by
ext; rfl | lemma | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | restrictScalars_fieldEquivOfAlgEquiv | null |
@[simp]
fieldEquivOfAlgEquiv_algebraMap (f : B ≃ₐ[A] C) (b : B) :
fieldEquivOfAlgEquiv FA FB FC f (algebraMap B FB b) = algebraMap C FC (f b) :=
ringEquivOfRingEquiv_algebraMap f.toRingEquiv b
variable (A B) in
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | fieldEquivOfAlgEquiv_algebraMap | This says that `fieldEquivOfAlgEquiv f` is an extension of `f` (i.e., it agrees with `f` on
`B`). Whereas `(fieldEquivOfAlgEquiv f).commutes` says that `fieldEquivOfAlgEquiv f` fixes `K`. |
fieldEquivOfAlgEquiv_refl :
fieldEquivOfAlgEquiv FA FB FB (AlgEquiv.refl : B ≃ₐ[A] B) = AlgEquiv.refl := by
ext x
obtain ⟨x, y, -, rfl⟩ := IsFractionRing.div_surjective (A := B) x
simp | lemma | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | fieldEquivOfAlgEquiv_refl | null |
fieldEquivOfAlgEquiv_trans (f : B ≃ₐ[A] C) (g : C ≃ₐ[A] D) :
fieldEquivOfAlgEquiv FA FB FD (f.trans g) =
(fieldEquivOfAlgEquiv FA FB FC f).trans (fieldEquivOfAlgEquiv FA FC FD g) := by
ext x
obtain ⟨x, y, -, rfl⟩ := IsFractionRing.div_surjective (A := B) x
simp | lemma | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | fieldEquivOfAlgEquiv_trans | null |
noncomputable fieldEquivOfAlgEquivHom : (B ≃ₐ[A] B) →* (L ≃ₐ[K] L) where
toFun := fieldEquivOfAlgEquiv K L L
map_one' := fieldEquivOfAlgEquiv_refl A B K L
map_mul' f g := fieldEquivOfAlgEquiv_trans K L L L g f
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | fieldEquivOfAlgEquivHom | An algebra automorphism of a ring induces an algebra automorphism of its fraction field.
This is a bundled version of `fieldEquivOfAlgEquiv`. |
fieldEquivOfAlgEquivHom_apply (f : B ≃ₐ[A] B) :
fieldEquivOfAlgEquivHom K L f = fieldEquivOfAlgEquiv K L L f :=
rfl
variable (A B) | lemma | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | fieldEquivOfAlgEquivHom_apply | null |
fieldEquivOfAlgEquivHom_injective :
Function.Injective (fieldEquivOfAlgEquivHom K L : (B ≃ₐ[A] B) →* (L ≃ₐ[K] L)) := by
intro f g h
ext b
simpa using AlgEquiv.ext_iff.mp h (algebraMap B L b) | lemma | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | fieldEquivOfAlgEquivHom_injective | null |
isFractionRing_iff_of_base_ringEquiv (h : R ≃+* P) :
IsFractionRing R S ↔
@IsFractionRing P _ S _ ((algebraMap R S).comp h.symm.toRingHom).toAlgebra := by
delta IsFractionRing
convert isLocalization_iff_of_base_ringEquiv (nonZeroDivisors R) S h
exact (MulEquivClass.map_nonZeroDivisors h).symm | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | isFractionRing_iff_of_base_ringEquiv | null |
protected nontrivial (R S : Type*) [CommRing R] [Nontrivial R] [CommRing S] [Algebra R S]
[IsFractionRing R S] : Nontrivial S := by
apply nontrivial_of_ne
· intro h
apply @zero_ne_one R
exact
IsLocalization.injective S (le_of_eq rfl)
(((algebraMap R S).map_zero.trans h).trans (algebraMap R S).map_one.symm) | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | nontrivial | null |
algebraMap_injective_of_field_isFractionRing (K L : Type*) [Field K] [Semiring L]
[Nontrivial L] [Algebra R K] [IsFractionRing R K] [Algebra S L] [Algebra K L] [Algebra R L]
[IsScalarTower R S L] [IsScalarTower R K L] : Function.Injective (algebraMap R S) := by
refine Function.Injective.of_comp (f := algebraMap S L) ?_
rw [← RingHom.coe_comp, ← IsScalarTower.algebraMap_eq, IsScalarTower.algebraMap_eq R K L]
exact (algebraMap K L).injective.comp (IsFractionRing.injective R K) | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | algebraMap_injective_of_field_isFractionRing | null |
FaithfulSMul.of_field_isFractionRing (K L : Type*) [Field K] [Semiring L]
[Nontrivial L] [Algebra R K] [IsFractionRing R K] [Algebra S L] [Algebra K L] [Algebra R L]
[IsScalarTower R S L] [IsScalarTower R K L] : FaithfulSMul R S :=
(faithfulSMul_iff_algebraMap_injective R S).mpr <|
algebraMap_injective_of_field_isFractionRing R S K L | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | FaithfulSMul.of_field_isFractionRing | null |
FractionRing :=
Localization (nonZeroDivisors R) | abbrev | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | FractionRing | The fraction ring of a commutative ring `R` as a quotient type.
We instantiate this definition as generally as possible, and assume that the
commutative ring `R` is an integral domain only when this is needed for proving.
In this generality, this construction is also known as the *total fraction ring* of `R`. |
unique [Subsingleton R] : Unique (FractionRing R) := inferInstance | instance | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | unique | null |
noncomputable field : Field (FractionRing A) := inferInstance
@[simp] | instance | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | field | null |
mk_eq_div {r s} :
(Localization.mk r s : FractionRing A) =
(algebraMap _ _ r / algebraMap A _ s : FractionRing A) := by
rw [Localization.mk_eq_mk', IsFractionRing.mk'_eq_div] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | mk_eq_div | null |
noncomputable liftAlgebra : Algebra (FractionRing R) K :=
have := (FaithfulSMul.algebraMap_injective R K).isDomain
RingHom.toAlgebra (IsFractionRing.lift (FaithfulSMul.algebraMap_injective R K))
attribute [local instance] liftAlgebra | abbrev | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | liftAlgebra | This is not an instance because it creates a diamond when `K = FractionRing R`.
Should usually be introduced locally along with `isScalarTower_liftAlgebra`
See note [reducible non-instances]. |
isScalarTower_liftAlgebra : IsScalarTower R (FractionRing R) K :=
have := (FaithfulSMul.algebraMap_injective R K).isDomain
.of_algebraMap_eq fun x ↦
(IsFractionRing.lift_algebraMap (FaithfulSMul.algebraMap_injective R K) x).symm | instance | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | isScalarTower_liftAlgebra | null |
algebraMap_liftAlgebra :
have := (FaithfulSMul.algebraMap_injective R K).isDomain
algebraMap (FractionRing R) K = IsFractionRing.lift (FaithfulSMul.algebraMap_injective R _) :=
rfl | lemma | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | algebraMap_liftAlgebra | null |
noncomputable algEquiv (K : Type*) [CommRing K] [Algebra A K] [IsFractionRing A K] :
FractionRing A ≃ₐ[A] K :=
Localization.algEquiv (nonZeroDivisors A) K | def | RingTheory | [
"Mathlib.Algebra.Ring.Hom.InjSurj",
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Field.Subfield.Basic",
"Mathlib.Algebra.Order.GroupWithZero.Submonoid",
"Mathlib.Algebra.Order.Ring.Int",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.SimpleRing.Basic"
] | Mathlib/RingTheory/Localization/FractionRing.lean | algEquiv | Given a ring `A` and a localization map to a fraction ring
`f : A →+* K`, we get an `A`-isomorphism between the fraction ring of `A` as a quotient
type and `K`. |
Module.FinitePresentation.exists_basis_localizedModule_powers
(Rₛ) [CommRing Rₛ] [Algebra R Rₛ] [Module Rₛ M'] [IsScalarTower R Rₛ M']
[IsLocalization S Rₛ] [Module.FinitePresentation R M]
{I} [Finite I] (b : Basis I Rₛ M') :
∃ (r : R) (hr : r ∈ S)
(b' : Basis I (Localization (.powers r)) (LocalizedModule (.powers r) M)),
∀ i, (LocalizedModule.lift (.powers r) f fun s ↦ IsLocalizedModule.map_units f
⟨s.1, SetLike.le_def.mp (Submonoid.powers_le.mpr hr) s.2⟩) (b' i) = b i := by
have : Module.FinitePresentation R (I →₀ R) := Module.finitePresentation_of_projective _ _
obtain ⟨r, hr, e, he⟩ := Module.FinitePresentation.exists_lift_equiv_of_isLocalizedModule S f
(Finsupp.mapRange.linearMap (Algebra.linearMap R Rₛ)) (b.repr.restrictScalars R)
let e' := IsLocalizedModule.iso (.powers r) (Finsupp.mapRange.linearMap (α := I)
(Algebra.linearMap R (Localization (.powers r))))
refine ⟨r, hr, .ofRepr (e ≪≫ₗ ?_), ?_⟩
· exact
{ __ := e',
toLinearMap := e'.extendScalarsOfIsLocalization (.powers r) (Localization (.powers r)) }
· intro i
have : e'.symm _ = _ := LinearMap.congr_fun (IsLocalizedModule.iso_symm_comp (.powers r)
(Finsupp.mapRange.linearMap (Algebra.linearMap R (Localization (.powers r)))))
(Finsupp.single i 1)
simp only [Finsupp.mapRange.linearMap_apply, Finsupp.mapRange_single, Algebra.linearMap_apply,
map_one, LocalizedModule.mkLinearMap_apply] at this
change LocalizedModule.lift _ _ _ (e.symm (e'.symm _)) = _
replace he := LinearMap.congr_fun he (e.symm (e'.symm (Finsupp.single i 1)))
simp only [LinearMap.coe_comp, LinearMap.coe_restrictScalars, LinearEquiv.coe_coe,
Function.comp_apply, LinearEquiv.apply_symm_apply, LinearEquiv.restrictScalars_apply] at he
apply b.repr.injective
rw [← he, Basis.repr_self, this, LocalizedModule.lift_mk]
simp
include f in | lemma | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Localization.Finiteness",
"Mathlib.LinearAlgebra.FreeModule.StrongRankCondition",
"Mathlib.LinearAlgebra.Dimension.StrongRankCondition"
] | Mathlib/RingTheory/Localization/Free.lean | Module.FinitePresentation.exists_basis_localizedModule_powers | If `M` is a finitely presented `R`-module,
then any `Rₛ`-basis of `Mₛ` for some `S : Submonoid R` can be lifted to
a `Rᵣ`-basis of `Mᵣ` for some `r ∈ S`. |
Module.FinitePresentation.exists_free_localizedModule_powers
(Rₛ) [CommRing Rₛ] [Algebra R Rₛ] [Module Rₛ M'] [IsScalarTower R Rₛ M'] [Nontrivial Rₛ]
[IsLocalization S Rₛ] [Module.FinitePresentation R M] [Module.Free Rₛ M'] :
∃ r, r ∈ S ∧
Module.Free (Localization (.powers r)) (LocalizedModule (.powers r) M) ∧
Module.finrank (Localization (.powers r)) (LocalizedModule (.powers r) M) =
Module.finrank Rₛ M' := by
let I := Module.Free.ChooseBasisIndex Rₛ M'
let b : Basis I Rₛ M' := Module.Free.chooseBasis Rₛ M'
have : Module.Finite Rₛ M' := Module.Finite.of_isLocalizedModule S (Rₚ := Rₛ) f
obtain ⟨r, hr, b', _⟩ := Module.FinitePresentation.exists_basis_localizedModule_powers S f Rₛ b
have := (show Localization (.powers r) →+* Rₛ from IsLocalization.map (M := .powers r) (T := S) _
(RingHom.id _) (Submonoid.powers_le.mpr hr)).domain_nontrivial
refine ⟨r, hr, .of_basis b', ?_⟩
rw [Module.finrank_eq_nat_card_basis b, Module.finrank_eq_nat_card_basis b'] | lemma | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.RingTheory.Localization.Finiteness",
"Mathlib.LinearAlgebra.FreeModule.StrongRankCondition",
"Mathlib.LinearAlgebra.Dimension.StrongRankCondition"
] | Mathlib/RingTheory/Localization/Free.lean | Module.FinitePresentation.exists_free_localizedModule_powers | If `M` is a finitely presented `R`-module
such that `Mₛ` is free over `Rₛ` for some `S : Submonoid R`,
then `Mᵣ` is already free over `Rᵣ` for some `r ∈ S`. |
mk'_mem_iff {x} {y : M} {I : Ideal S} : mk' S x y ∈ I ↔ algebraMap R S x ∈ I := by
constructor <;> intro h
· rw [← mk'_spec S x y, mul_comm]
exact I.mul_mem_left ((algebraMap R S) y) h
· rw [← mk'_spec S x y] at h
obtain ⟨b, hb⟩ := isUnit_iff_exists_inv.1 (map_units S y)
have := I.mul_mem_left b h
rwa [mul_comm, mul_assoc, hb, mul_one] at this | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.Spectrum.Prime.Defs",
"Mathlib.Algebra.Algebra.Tower"
] | Mathlib/RingTheory/Localization/Ideal.lean | mk'_mem_iff | null |
orderEmbedding : Ideal S ↪o Ideal R where
toFun J := Ideal.comap (algebraMap R S) J
inj' := Function.LeftInverse.injective (map_comap M S)
map_rel_iff' := by
rintro J₁ J₂
constructor
· exact fun hJ => (map_comap M S) J₁ ▸ (map_comap M S) J₂ ▸ Ideal.map_mono hJ
· exact fun hJ => Ideal.comap_mono hJ | def | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.Spectrum.Prime.Defs",
"Mathlib.Algebra.Algebra.Tower"
] | Mathlib/RingTheory/Localization/Ideal.lean | orderEmbedding | Explicit characterization of the ideal given by `Ideal.map (algebraMap R S) I`.
In practice, this ideal differs only in that the carrier set is defined explicitly.
This definition is only meant to be used in proving `mem_map_algebraMap_iff`,
and any proof that needs to refer to the explicit carrier set should use that theorem. -/
-- TODO: golf this using `Submodule.localized'`
private def map_ideal (I : Ideal R) : Ideal S where
carrier := { z : S | ∃ x : I × M, z * algebraMap R S x.2 = algebraMap R S x.1 }
zero_mem' := ⟨⟨0, 1⟩, by simp⟩
add_mem' := by
rintro a b ⟨a', ha⟩ ⟨b', hb⟩
let Z : { x // x ∈ I } := ⟨(a'.2 : R) * (b'.1 : R) + (b'.2 : R) * (a'.1 : R),
I.add_mem (I.mul_mem_left _ b'.1.2) (I.mul_mem_left _ a'.1.2)⟩
use ⟨Z, a'.2 * b'.2⟩
simp only [Z, RingHom.map_add, Submonoid.coe_mul, RingHom.map_mul]
rw [add_mul, ← mul_assoc a, ha, mul_comm (algebraMap R S a'.2) (algebraMap R S b'.2), ←
mul_assoc b, hb]
ring
smul_mem' := by
rintro c x ⟨x', hx⟩
obtain ⟨c', hc⟩ := IsLocalization.surj M c
let Z : { x // x ∈ I } := ⟨c'.1 * x'.1, I.mul_mem_left c'.1 x'.1.2⟩
use ⟨Z, c'.2 * x'.2⟩
simp only [Z, ← hx, ← hc, smul_eq_mul, Submonoid.coe_mul, RingHom.map_mul]
ring
theorem mem_map_algebraMap_iff {I : Ideal R} {z} : z ∈ Ideal.map (algebraMap R S) I ↔
∃ x : I × M, z * algebraMap R S x.2 = algebraMap R S x.1 := by
constructor
· change _ → z ∈ map_ideal M S I
refine fun h => Ideal.mem_sInf.1 h fun z hz => ?_
obtain ⟨y, hy⟩ := hz
let Z : { x // x ∈ I } := ⟨y, hy.left⟩
use ⟨Z, 1⟩
simp [Z, hy.right]
· rintro ⟨⟨a, s⟩, h⟩
rw [← Ideal.unit_mul_mem_iff_mem _ (map_units S s), mul_comm]
exact h.symm ▸ Ideal.mem_map_of_mem _ a.2
lemma mk'_mem_map_algebraMap_iff (I : Ideal R) (x : R) (s : M) :
IsLocalization.mk' S x s ∈ I.map (algebraMap R S) ↔ ∃ s ∈ M, s * x ∈ I := by
rw [← Ideal.unit_mul_mem_iff_mem _ (IsLocalization.map_units S s), IsLocalization.mk'_spec',
IsLocalization.mem_map_algebraMap_iff M]
simp_rw [← map_mul, IsLocalization.eq_iff_exists M, mul_comm x, ← mul_assoc, ← Submonoid.coe_mul]
exact ⟨fun ⟨⟨y, t⟩, c, h⟩ ↦ ⟨_, (c * t).2, h ▸ I.mul_mem_left c.1 y.2⟩, fun ⟨s, hs, h⟩ ↦
⟨⟨⟨_, h⟩, ⟨s, hs⟩⟩, 1, by simp⟩⟩
lemma algebraMap_mem_map_algebraMap_iff (I : Ideal R) (x : R) :
algebraMap R S x ∈ I.map (algebraMap R S) ↔
∃ m ∈ M, m * x ∈ I := by
rw [← IsLocalization.mk'_one (M := M), mk'_mem_map_algebraMap_iff]
lemma map_algebraMap_ne_top_iff_disjoint (I : Ideal R) :
I.map (algebraMap R S) ≠ ⊤ ↔ Disjoint (M : Set R) (I : Set R) := by
simp only [ne_eq, Ideal.eq_top_iff_one, ← map_one (algebraMap R S), not_iff_comm,
IsLocalization.algebraMap_mem_map_algebraMap_iff M]
simp [Set.disjoint_left]
include M in
theorem map_comap (J : Ideal S) :
Ideal.map (algebraMap R S) (Ideal.comap (algebraMap R S) J) = J :=
le_antisymm (Ideal.map_le_iff_le_comap.2 le_rfl) fun x hJ => by
obtain ⟨r, s, hx⟩ := mk'_surjective M x
rw [← hx] at hJ ⊢
exact
Ideal.mul_mem_right _ _
(Ideal.mem_map_of_mem _
(show (algebraMap R S) r ∈ J from
mk'_spec S r s ▸ J.mul_mem_right ((algebraMap R S) s) hJ))
theorem comap_map_of_isPrime_disjoint (I : Ideal R) (hI : I.IsPrime) (hM : Disjoint (M : Set R) I) :
Ideal.comap (algebraMap R S) (Ideal.map (algebraMap R S) I) = I := by
refine le_antisymm ?_ Ideal.le_comap_map
refine (fun a ha => ?_)
obtain ⟨⟨b, s⟩, h⟩ := (mem_map_algebraMap_iff M S).1 (Ideal.mem_comap.1 ha)
replace h : algebraMap R S (s * a) = algebraMap R S b := by
simpa only [← map_mul, mul_comm] using h
obtain ⟨c, hc⟩ := (eq_iff_exists M S).1 h
have : ↑c * ↑s * a ∈ I := by
rw [mul_assoc, hc]
exact I.mul_mem_left c b.2
exact (hI.mem_or_mem this).resolve_left fun hsc => hM.le_bot ⟨(c * s).2, hsc⟩
/-- If `S` is the localization of `R` at a submonoid, the ordering of ideals of `S` is
embedded in the ordering of ideals of `R`. |
isPrime_iff_isPrime_disjoint (J : Ideal S) :
J.IsPrime ↔
(Ideal.comap (algebraMap R S) J).IsPrime ∧
Disjoint (M : Set R) ↑(Ideal.comap (algebraMap R S) J) := by
constructor
· refine fun h =>
⟨⟨?_, ?_⟩,
Set.disjoint_left.mpr fun m hm1 hm2 =>
h.ne_top (Ideal.eq_top_of_isUnit_mem _ hm2 (map_units S ⟨m, hm1⟩))⟩
· refine fun hJ => h.ne_top ?_
rw [eq_top_iff, ← (orderEmbedding M S).le_iff_le]
exact le_of_eq hJ.symm
· intro x y hxy
rw [Ideal.mem_comap, RingHom.map_mul] at hxy
exact h.mem_or_mem hxy
· refine fun h => ⟨fun hJ => h.left.ne_top (eq_top_iff.2 ?_), ?_⟩
· rwa [eq_top_iff, ← (orderEmbedding M S).le_iff_le] at hJ
· intro x y hxy
obtain ⟨a, s, ha⟩ := mk'_surjective M x
obtain ⟨b, t, hb⟩ := mk'_surjective M y
have : mk' S (a * b) (s * t) ∈ J := by rwa [mk'_mul, ha, hb]
rw [mk'_mem_iff, ← Ideal.mem_comap] at this
have this₂ := (h.1).mul_mem_iff_mem_or_mem.1 this
rw [Ideal.mem_comap, Ideal.mem_comap] at this₂
rwa [← ha, ← hb, mk'_mem_iff, mk'_mem_iff] | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.Spectrum.Prime.Defs",
"Mathlib.Algebra.Algebra.Tower"
] | Mathlib/RingTheory/Localization/Ideal.lean | isPrime_iff_isPrime_disjoint | If `R` is a ring, then prime ideals in the localization at `M`
correspond to prime ideals in the original ring `R` that are disjoint from `M`.
This lemma gives the particular case for an ideal and its comap,
see `le_rel_iso_of_prime` for the more general relation isomorphism |
isPrime_of_isPrime_disjoint (I : Ideal R) (hp : I.IsPrime) (hd : Disjoint (M : Set R) ↑I) :
(Ideal.map (algebraMap R S) I).IsPrime := by
rw [isPrime_iff_isPrime_disjoint M S, comap_map_of_isPrime_disjoint M S I hp hd]
exact ⟨hp, hd⟩ | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.Spectrum.Prime.Defs",
"Mathlib.Algebra.Algebra.Tower"
] | Mathlib/RingTheory/Localization/Ideal.lean | isPrime_of_isPrime_disjoint | If `R` is a ring, then prime ideals in the localization at `M`
correspond to prime ideals in the original ring `R` that are disjoint from `M`.
This lemma gives the particular case for an ideal and its map,
see `le_rel_iso_of_prime` for the more general relation isomorphism, and the reverse implication |
disjoint_comap_iff (J : Ideal S) :
Disjoint (M : Set R) (J.comap (algebraMap R S)) ↔ J ≠ ⊤ := by
rw [← iff_not_comm, Set.not_disjoint_iff]
constructor
· rintro rfl
exact ⟨1, M.one_mem, ⟨⟩⟩
· rintro ⟨x, hxM, hxJ⟩
exact J.eq_top_of_isUnit_mem hxJ (IsLocalization.map_units S ⟨x, hxM⟩) | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.Spectrum.Prime.Defs",
"Mathlib.Algebra.Algebra.Tower"
] | Mathlib/RingTheory/Localization/Ideal.lean | disjoint_comap_iff | null |
@[simps] orderIsoOfPrime :
{ p : Ideal S // p.IsPrime } ≃o { p : Ideal R // p.IsPrime ∧ Disjoint (M : Set R) ↑p } where
toFun p := ⟨Ideal.comap (algebraMap R S) p.1, (isPrime_iff_isPrime_disjoint M S p.1).1 p.2⟩
invFun p := ⟨Ideal.map (algebraMap R S) p.1, isPrime_of_isPrime_disjoint M S p.1 p.2.1 p.2.2⟩
left_inv J := Subtype.eq (map_comap M S J)
right_inv I := Subtype.eq (comap_map_of_isPrime_disjoint M S I.1 I.2.1 I.2.2)
map_rel_iff' {I I'} := by
constructor
· exact fun h => show I.val ≤ I'.val from map_comap M S I.val ▸
map_comap M S I'.val ▸ Ideal.map_mono h
exact fun h x hx => h hx | def | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.Spectrum.Prime.Defs",
"Mathlib.Algebra.Algebra.Tower"
] | Mathlib/RingTheory/Localization/Ideal.lean | orderIsoOfPrime | If `R` is a ring, then prime ideals in the localization at `M`
correspond to prime ideals in the original ring `R` that are disjoint from `M` |
@[simps!] primeSpectrumOrderIso :
PrimeSpectrum S ≃o {p : PrimeSpectrum R // Disjoint (M : Set R) p.asIdeal} :=
(PrimeSpectrum.equivSubtype S).trans <| (orderIsoOfPrime M S).trans
⟨⟨fun p ↦ ⟨⟨p, p.2.1⟩, p.2.2⟩, fun p ↦ ⟨p.1.1, p.1.2, p.2⟩, fun _ ↦ rfl, fun _ ↦ rfl⟩, .rfl⟩
include M in | def | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.Spectrum.Prime.Defs",
"Mathlib.Algebra.Algebra.Tower"
] | Mathlib/RingTheory/Localization/Ideal.lean | primeSpectrumOrderIso | The prime spectrum of the localization of a ring at a submonoid `M` are in
order-preserving bijection with subset of the prime spectrum of the ring consisting of
prime ideals disjoint from `M`. |
map_radical (I : Ideal R) :
I.radical.map (algebraMap R S) = (I.map (algebraMap R S)).radical := by
refine (I.map_radical_le (algebraMap R S)).antisymm ?_
rintro x ⟨n, hn⟩
obtain ⟨x, s, rfl⟩ := IsLocalization.mk'_surjective M x
simp only [← IsLocalization.mk'_pow, IsLocalization.mk'_mem_map_algebraMap_iff M] at hn ⊢
obtain ⟨s, hs, h⟩ := hn
refine ⟨s, hs, n + 1, by convert I.mul_mem_left (s ^ n * x) h; ring⟩ | lemma | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.Spectrum.Prime.Defs",
"Mathlib.Algebra.Algebra.Tower"
] | Mathlib/RingTheory/Localization/Ideal.lean | map_radical | null |
ideal_eq_iInf_comap_map_away {S : Finset R} (hS : Ideal.span (α := R) S = ⊤) (I : Ideal R) :
I = ⨅ f ∈ S, (I.map (algebraMap R (Localization.Away f))).comap
(algebraMap R (Localization.Away f)) := by
apply le_antisymm
· simp only [le_iInf₂_iff, ← Ideal.map_le_iff_le_comap, le_refl, implies_true]
· intro x hx
apply Submodule.mem_of_span_eq_top_of_smul_pow_mem _ _ hS
rintro ⟨s, hs⟩
simp only [Ideal.mem_iInf, Ideal.mem_comap] at hx
obtain ⟨⟨y, ⟨_, n, rfl⟩⟩, e⟩ :=
(IsLocalization.mem_map_algebraMap_iff (.powers s) _).mp (hx s hs)
dsimp only at e
rw [← map_mul, IsLocalization.eq_iff_exists (.powers s)] at e
obtain ⟨⟨_, m, rfl⟩, e⟩ := e
use m + n
dsimp at e ⊢
rw [pow_add, mul_assoc, ← mul_comm x, e]
exact I.mul_mem_left _ y.2 | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.Spectrum.Prime.Defs",
"Mathlib.Algebra.Algebra.Tower"
] | Mathlib/RingTheory/Localization/Ideal.lean | ideal_eq_iInf_comap_map_away | null |
surjective_quotientMap_of_maximal_of_localization {I : Ideal S} [I.IsPrime] {J : Ideal R}
{H : J ≤ I.comap (algebraMap R S)} (hI : (I.comap (algebraMap R S)).IsMaximal) :
Function.Surjective (Ideal.quotientMap I (algebraMap R S) H) := by
intro s
obtain ⟨s, rfl⟩ := Ideal.Quotient.mk_surjective s
obtain ⟨r, ⟨m, hm⟩, rfl⟩ := mk'_surjective M s
by_cases hM : (Ideal.Quotient.mk (I.comap (algebraMap R S))) m = 0
· have : I = ⊤ := by
rw [Ideal.eq_top_iff_one]
rw [Ideal.Quotient.eq_zero_iff_mem, Ideal.mem_comap] at hM
convert I.mul_mem_right (mk' S (1 : R) ⟨m, hm⟩) hM
rw [← mk'_eq_mul_mk'_one, mk'_self]
exact ⟨0, eq_comm.1 (by simp [Ideal.Quotient.eq_zero_iff_mem, this])⟩
· rw [Ideal.Quotient.maximal_ideal_iff_isField_quotient] at hI
obtain ⟨n, hn⟩ := hI.3 hM
obtain ⟨rn, rfl⟩ := Ideal.Quotient.mk_surjective n
refine ⟨(Ideal.Quotient.mk J) (r * rn), ?_⟩
replace hn := congr_arg (Ideal.quotientMap I (algebraMap R S) le_rfl) hn
rw [RingHom.map_one, RingHom.map_mul] at hn
rw [Ideal.quotientMap_mk, ← sub_eq_zero, ← RingHom.map_sub, Ideal.Quotient.eq_zero_iff_mem, ←
Ideal.Quotient.eq_zero_iff_mem, RingHom.map_sub, sub_eq_zero, mk'_eq_mul_mk'_one]
simp only [mul_eq_mul_left_iff, RingHom.map_mul]
refine
Or.inl
(mul_left_cancel₀ (M₀ := S ⧸ I)
(fun hn =>
hM
(Ideal.Quotient.eq_zero_iff_mem.2
(Ideal.mem_comap.2 (Ideal.Quotient.eq_zero_iff_mem.1 hn))))
(_root_.trans hn ?_))
rw [← map_mul, ← mk'_eq_mul_mk'_one, mk'_self, RingHom.map_one]
open nonZeroDivisors | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.Spectrum.Prime.Defs",
"Mathlib.Algebra.Algebra.Tower"
] | Mathlib/RingTheory/Localization/Ideal.lean | surjective_quotientMap_of_maximal_of_localization | `quotientMap` applied to maximal ideals of a localization is `surjective`.
The quotient by a maximal ideal is a field, so inverses to elements already exist,
and the localization necessarily maps the equivalence class of the inverse in the localization |
bot_lt_comap_prime [IsDomain R] (hM : M ≤ R⁰) (p : Ideal S) [hpp : p.IsPrime]
(hp0 : p ≠ ⊥) : ⊥ < Ideal.comap (algebraMap R S) p := by
haveI : IsDomain S := isDomain_of_le_nonZeroDivisors _ hM
rw [← Ideal.comap_bot_of_injective (algebraMap R S) (IsLocalization.injective _ hM)]
convert (orderIsoOfPrime M S).lt_iff_lt.mpr (show (⟨⊥, Ideal.bot_prime⟩ :
{ p : Ideal S // p.IsPrime }) < ⟨p, hpp⟩ from hp0.bot_lt)
variable (R) in | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.Spectrum.Prime.Defs",
"Mathlib.Algebra.Algebra.Tower"
] | Mathlib/RingTheory/Localization/Ideal.lean | bot_lt_comap_prime | null |
_root_.NoZeroSMulDivisors_of_isLocalization (Rₚ Sₚ : Type*) [CommRing Rₚ] [CommRing Sₚ]
[Algebra R Rₚ] [Algebra R Sₚ] [Algebra S Sₚ] [Algebra Rₚ Sₚ] [IsScalarTower R S Sₚ]
[IsScalarTower R Rₚ Sₚ] {M : Submonoid R} (hM : M ≤ R⁰) [IsLocalization M Rₚ]
[IsLocalization (Algebra.algebraMapSubmonoid S M) Sₚ] [NoZeroSMulDivisors R S] [IsDomain S] :
NoZeroSMulDivisors Rₚ Sₚ := by
have e : Algebra.algebraMapSubmonoid S M ≤ S⁰ :=
Submonoid.map_le_of_le_comap _ <| hM.trans
(nonZeroDivisors_le_comap_nonZeroDivisors_of_injective _
(FaithfulSMul.algebraMap_injective _ _))
have : IsDomain Sₚ := IsLocalization.isDomain_of_le_nonZeroDivisors _ e
have : algebraMap Rₚ Sₚ = IsLocalization.map (T := Algebra.algebraMapSubmonoid S M) Sₚ
(algebraMap R S) (Submonoid.le_comap_map M) := by
apply IsLocalization.ringHom_ext M
simp only [IsLocalization.map_comp, ← IsScalarTower.algebraMap_eq]
rw [NoZeroSMulDivisors.iff_algebraMap_injective, RingHom.injective_iff_ker_eq_bot,
RingHom.ker_eq_bot_iff_eq_zero]
intro x hx
obtain ⟨x, s, rfl⟩ := IsLocalization.mk'_surjective M x
simp only [IsLocalization.map_mk', IsLocalization.mk'_eq_zero_iff,
Subtype.exists, exists_prop, this] at hx ⊢
obtain ⟨_, ⟨a, ha, rfl⟩, H⟩ := hx
simp only [← map_mul,
(injective_iff_map_eq_zero' _).mp (FaithfulSMul.algebraMap_injective R S)] at H
exact ⟨a, ha, H⟩ | lemma | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.Spectrum.Prime.Defs",
"Mathlib.Algebra.Algebra.Tower"
] | Mathlib/RingTheory/Localization/Ideal.lean | _root_.NoZeroSMulDivisors_of_isLocalization | null |
of_surjective {R' S' : Type*} [CommRing R'] [CommRing S'] [Algebra R' S']
(f : R →+* R') (hf : Function.Surjective f) (g : S →+* S') (hg : Function.Surjective g)
(H : g.comp (algebraMap R S) = (algebraMap _ _).comp f)
(H' : RingHom.ker g ≤ (RingHom.ker f).map (algebraMap R S)) : IsLocalization (M.map f) S' where
map_units := by
rintro ⟨_, y, hy, rfl⟩
simpa only [← RingHom.comp_apply, H] using (IsLocalization.map_units S ⟨y, hy⟩).map g
surj := by
intro z
obtain ⟨z, rfl⟩ := hg z
obtain ⟨⟨r, s⟩, e⟩ := IsLocalization.surj M z
refine ⟨⟨f r, _, s.1, s.2, rfl⟩, ?_⟩
simpa only [map_mul, ← RingHom.comp_apply, H] using DFunLike.congr_arg g e
exists_of_eq := by
intro x y e
obtain ⟨x, rfl⟩ := hf x
obtain ⟨y, rfl⟩ := hf y
rw [← sub_eq_zero, ← map_sub, ← map_sub, ← RingHom.comp_apply, ← H, RingHom.comp_apply,
← IsLocalization.mk'_one (M := M)] at e
obtain ⟨r, hr, hr'⟩ := (IsLocalization.mk'_mem_map_algebraMap_iff M _ _ _ _).mp (H' e)
exact ⟨⟨_, r, hr, rfl⟩, by simpa [sub_eq_zero, mul_sub] using hr'⟩
open Algebra in | lemma | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.Spectrum.Prime.Defs",
"Mathlib.Algebra.Algebra.Tower"
] | Mathlib/RingTheory/Localization/Ideal.lean | of_surjective | null |
IsInteger (a : S) : Prop :=
a ∈ (algebraMap R S).rangeS | def | RingTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Scalar",
"Mathlib.Algebra.Ring.Subsemiring.Basic",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/Integer.lean | IsInteger | Given `a : S`, `S` a localization of `R`, `IsInteger R a` iff `a` is in the image of
the localization map from `R` to `S`. |
isInteger_zero : IsInteger R (0 : S) :=
Subsemiring.zero_mem _ | theorem | RingTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Scalar",
"Mathlib.Algebra.Ring.Subsemiring.Basic",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/Integer.lean | isInteger_zero | null |
isInteger_one : IsInteger R (1 : S) :=
Subsemiring.one_mem _ | theorem | RingTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Scalar",
"Mathlib.Algebra.Ring.Subsemiring.Basic",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/Integer.lean | isInteger_one | null |
isInteger_add {a b : S} (ha : IsInteger R a) (hb : IsInteger R b) : IsInteger R (a + b) :=
Subsemiring.add_mem _ ha hb | theorem | RingTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Scalar",
"Mathlib.Algebra.Ring.Subsemiring.Basic",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/Integer.lean | isInteger_add | null |
isInteger_mul {a b : S} (ha : IsInteger R a) (hb : IsInteger R b) : IsInteger R (a * b) :=
Subsemiring.mul_mem _ ha hb | theorem | RingTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Scalar",
"Mathlib.Algebra.Ring.Subsemiring.Basic",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/Integer.lean | isInteger_mul | null |
isInteger_smul {a : R} {b : S} (hb : IsInteger R b) : IsInteger R (a • b) := by
rcases hb with ⟨b', hb⟩
use a * b'
rw [← hb, (algebraMap R S).map_mul, Algebra.smul_def]
variable (M)
variable [IsLocalization M S] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Scalar",
"Mathlib.Algebra.Ring.Subsemiring.Basic",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/Integer.lean | isInteger_smul | null |
exists_integer_multiple' (a : S) : ∃ b : M, IsInteger R (a * algebraMap R S b) :=
let ⟨⟨Num, denom⟩, h⟩ := IsLocalization.surj _ a
⟨denom, Set.mem_range.mpr ⟨Num, h.symm⟩⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Scalar",
"Mathlib.Algebra.Ring.Subsemiring.Basic",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/Integer.lean | exists_integer_multiple' | Each element `a : S` has an `M`-multiple which is an integer.
This version multiplies `a` on the right, matching the argument order in `LocalizationMap.surj`. |
exists_integer_multiple (a : S) : ∃ b : M, IsInteger R ((b : R) • a) := by
simp_rw [Algebra.smul_def, mul_comm _ a]
apply exists_integer_multiple' | theorem | RingTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Scalar",
"Mathlib.Algebra.Ring.Subsemiring.Basic",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/Integer.lean | exists_integer_multiple | Each element `a : S` has an `M`-multiple which is an integer.
This version multiplies `a` on the left, matching the argument order in the `SMul` instance. |
exist_integer_multiples {ι : Type*} (s : Finset ι) (f : ι → S) :
∃ b : M, ∀ i ∈ s, IsLocalization.IsInteger R ((b : R) • f i) := by
haveI := Classical.propDecidable
refine ⟨∏ i ∈ s, (sec M (f i)).2, fun i hi => ⟨?_, ?_⟩⟩
· exact (∏ j ∈ s.erase i, (sec M (f j)).2) * (sec M (f i)).1
rw [RingHom.map_mul, sec_spec', ← mul_assoc, ← (algebraMap R S).map_mul, ← Algebra.smul_def]
congr 2
refine _root_.trans ?_ (map_prod (Submonoid.subtype M) _ _).symm
rw [mul_comm,Submonoid.coe_finset_prod,
← Finset.prod_insert (f := fun i => ((sec M (f i)).snd : R)) (s.notMem_erase i),
Finset.insert_erase hi]
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Scalar",
"Mathlib.Algebra.Ring.Subsemiring.Basic",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/Integer.lean | exist_integer_multiples | We can clear the denominators of a `Finset`-indexed family of fractions. |
exist_integer_multiples_of_finite {ι : Type*} [Finite ι] (f : ι → S) :
∃ b : M, ∀ i, IsLocalization.IsInteger R ((b : R) • f i) := by
cases nonempty_fintype ι
obtain ⟨b, hb⟩ := exist_integer_multiples M Finset.univ f
exact ⟨b, fun i => hb i (Finset.mem_univ _)⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Scalar",
"Mathlib.Algebra.Ring.Subsemiring.Basic",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/Integer.lean | exist_integer_multiples_of_finite | We can clear the denominators of a finite indexed family of fractions. |
exist_integer_multiples_of_finset (s : Finset S) :
∃ b : M, ∀ a ∈ s, IsInteger R ((b : R) • a) :=
exist_integer_multiples M s id | theorem | RingTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Scalar",
"Mathlib.Algebra.Ring.Subsemiring.Basic",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/Integer.lean | exist_integer_multiples_of_finset | We can clear the denominators of a finite set of fractions. |
noncomputable commonDenom {ι : Type*} (s : Finset ι) (f : ι → S) : M :=
(exist_integer_multiples M s f).choose | def | RingTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Scalar",
"Mathlib.Algebra.Ring.Subsemiring.Basic",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/Integer.lean | commonDenom | A choice of a common multiple of the denominators of a `Finset`-indexed family of fractions. |
noncomputable integerMultiple {ι : Type*} (s : Finset ι) (f : ι → S) (i : s) : R :=
((exist_integer_multiples M s f).choose_spec i i.prop).choose
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Scalar",
"Mathlib.Algebra.Ring.Subsemiring.Basic",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/Integer.lean | integerMultiple | The numerator of a fraction after clearing the denominators
of a `Finset`-indexed family of fractions. |
map_integerMultiple {ι : Type*} (s : Finset ι) (f : ι → S) (i : s) :
algebraMap R S (integerMultiple M s f i) = commonDenom M s f • f i :=
((exist_integer_multiples M s f).choose_spec _ i.prop).choose_spec | theorem | RingTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Scalar",
"Mathlib.Algebra.Ring.Subsemiring.Basic",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/Integer.lean | map_integerMultiple | null |
noncomputable commonDenomOfFinset (s : Finset S) : M :=
commonDenom M s id | def | RingTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Scalar",
"Mathlib.Algebra.Ring.Subsemiring.Basic",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/Integer.lean | commonDenomOfFinset | A choice of a common multiple of the denominators of a finite set of fractions. |
noncomputable finsetIntegerMultiple [DecidableEq R] (s : Finset S) : Finset R :=
s.attach.image fun t => integerMultiple M s id t
open Pointwise | def | RingTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Scalar",
"Mathlib.Algebra.Ring.Subsemiring.Basic",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/Integer.lean | finsetIntegerMultiple | The finset of numerators after clearing the denominators of a finite set of fractions. |
finsetIntegerMultiple_image [DecidableEq R] (s : Finset S) :
algebraMap R S '' finsetIntegerMultiple M s = commonDenomOfFinset M s • (s : Set S) := by
delta finsetIntegerMultiple commonDenom
rw [Finset.coe_image]
ext
constructor
· rintro ⟨_, ⟨x, -, rfl⟩, rfl⟩
rw [map_integerMultiple]
exact Set.mem_image_of_mem _ x.prop
· rintro ⟨x, hx, rfl⟩
exact ⟨_, ⟨⟨x, hx⟩, s.mem_attach _, rfl⟩, map_integerMultiple M s id _⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Scalar",
"Mathlib.Algebra.Ring.Subsemiring.Basic",
"Mathlib.RingTheory.Localization.Defs"
] | Mathlib/RingTheory/Localization/Integer.lean | finsetIntegerMultiple_image | null |
noncomputable coeffIntegerNormalization (p : S[X]) (i : ℕ) : R :=
if hi : i ∈ p.support then
Classical.choose
(Classical.choose_spec (exist_integer_multiples_of_finset M (p.support.image p.coeff))
(p.coeff i) (Finset.mem_image.mpr ⟨i, hi, rfl⟩))
else 0 | def | 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 | coeffIntegerNormalization | `coeffIntegerNormalization p` gives the coefficients of the polynomial
`integerNormalization p` |
coeffIntegerNormalization_of_coeff_zero (p : S[X]) (i : ℕ) (h : coeff p i = 0) :
coeffIntegerNormalization M p i = 0 := by
simp only [coeffIntegerNormalization, h, mem_support_iff, not_true, Ne,
dif_neg, not_false_iff]
@[deprecated (since := "2025-05-23")]
alias coeffIntegerNormalization_of_not_mem_support := 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 | coeffIntegerNormalization_of_coeff_zero | null |
coeffIntegerNormalization_mem_support (p : S[X]) (i : ℕ)
(h : coeffIntegerNormalization M p i ≠ 0) : i ∈ p.support := by
contrapose h
rw [Ne, Classical.not_not, coeffIntegerNormalization, dif_neg h] | 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 | coeffIntegerNormalization_mem_support | null |
noncomputable integerNormalization (p : S[X]) : R[X] :=
∑ i ∈ p.support, monomial i (coeffIntegerNormalization M p i)
@[simp] | def | 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 | `integerNormalization g` normalizes `g` to have integer coefficients
by clearing the denominators |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.