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 ⌀ |
|---|---|---|---|---|---|---|
Algebra.IsPushout.isIntegral [h : IsPushout R S A SA] : Algebra.IsIntegral A SA :=
h.symm.isIntegral'
attribute [local instance] Polynomial.algebra in | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | Algebra.IsPushout.isIntegral | null |
RingHom.isIntegralElem_leadingCoeff_mul (h : p.eval₂ f x = 0) :
f.IsIntegralElem (f p.leadingCoeff * x) := by
by_cases h' : 1 ≤ p.natDegree
· use integralNormalization p
have : p ≠ 0 := fun h'' => by
rw [h'', natDegree_zero] at h'
exact Nat.not_succ_le_zero 0 h'
use monic_integralNormalization this
rw [integralNormalization_eval₂_leadingCoeff_mul h' f x, h, mul_zero]
· by_cases hp : p.map f = 0
· apply_fun fun q => coeff q p.natDegree at hp
rw [coeff_map, coeff_zero, coeff_natDegree] at hp
rw [hp, zero_mul]
exact f.isIntegralElem_zero
· rw [Nat.one_le_iff_ne_zero, Classical.not_not] at h'
rw [eq_C_of_natDegree_eq_zero h', eval₂_C] at h
suffices p.map f = 0 by exact (hp this).elim
rw [eq_C_of_natDegree_eq_zero h', map_C, h, C_eq_zero] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | RingHom.isIntegralElem_leadingCoeff_mul | Given a `p : R[X]` and a `x : S` such that `p.eval₂ f x = 0`,
`f p.leadingCoeff * x` is integral. |
isIntegral_leadingCoeff_smul [Algebra R S] (h : aeval x p = 0) :
IsIntegral R (p.leadingCoeff • x) := by
rw [aeval_def] at h
rw [Algebra.smul_def]
exact (algebraMap R S).isIntegralElem_leadingCoeff_mul p x h | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | isIntegral_leadingCoeff_smul | Given a `p : R[X]` and a root `x : S`,
then `p.leadingCoeff • x : S` is integral over `R`. |
Polynomial.Monic.quotient_isIntegralElem {g : S[X]} (mon : g.Monic) {I : Ideal S[X]}
(h : g ∈ I) :
((Ideal.Quotient.mk I).comp (algebraMap S S[X])).IsIntegralElem (Ideal.Quotient.mk I X) := by
exact ⟨g, mon, by
rw [← (Ideal.Quotient.eq_zero_iff_mem.mpr h), eval₂_eq_sum_range]
nth_rw 3 [(as_sum_range_C_mul_X_pow g)]
simp only [map_sum, algebraMap_eq, RingHom.coe_comp, Function.comp_apply, map_mul, map_pow]⟩
/- If `I` is an ideal of the polynomial ring `S[X]` and contains a monic polynomial `f`,
then `S[X]/I` is integral over `S`. -/ | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | Polynomial.Monic.quotient_isIntegralElem | null |
Polynomial.Monic.quotient_isIntegral {g : S[X]} (mon : g.Monic) {I : Ideal S[X]} (h : g ∈ I) :
((Ideal.Quotient.mkₐ S I).comp (Algebra.ofId S S[X])).IsIntegral := by
have eq_top : Algebra.adjoin S {(Ideal.Quotient.mkₐ S I) X} = ⊤ := by
ext g
constructor
· simp only [Algebra.mem_top, implies_true]
· intro _
obtain ⟨g', hg⟩ := Ideal.Quotient.mkₐ_surjective S I g
have : g = (Polynomial.aeval ((Ideal.Quotient.mkₐ S I) X)) g' := by
nth_rw 1 [← hg, aeval_eq_sum_range' (lt_add_one _),
as_sum_range_C_mul_X_pow g', map_sum]
simp only [Polynomial.C_mul', ← map_pow, map_smul]
exact this ▸ (aeval_mem_adjoin_singleton S ((Ideal.Quotient.mk I) Polynomial.X))
exact fun a ↦ (eq_top ▸ adjoin_le_integralClosure <| mon.quotient_isIntegralElem h)
Algebra.mem_top | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | Polynomial.Monic.quotient_isIntegral | null |
integralClosure.isIntegralClosure (R A : Type*) [CommRing R] [CommRing A] [Algebra R A] :
IsIntegralClosure (integralClosure R A) R A where
algebraMap_injective := Subtype.coe_injective
isIntegral_iff {x} := ⟨fun h => ⟨⟨x, h⟩, rfl⟩, by rintro ⟨⟨_, h⟩, rfl⟩; exact h⟩ | instance | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | integralClosure.isIntegralClosure | null |
protected isIntegral [Algebra R A] [IsScalarTower R A B] (x : A) : IsIntegral R x :=
(isIntegral_algebraMap_iff (algebraMap_injective A R B)).mp <|
show IsIntegral R (algebraMap A B x) from isIntegral_iff.mpr ⟨x, rfl⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | isIntegral | null |
isIntegral_algebra [Algebra R A] [IsScalarTower R A B] : Algebra.IsIntegral R A :=
⟨fun x => IsIntegralClosure.isIntegral R B x⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | isIntegral_algebra | null |
noZeroSMulDivisors [SMul R A] [IsScalarTower R A B] [NoZeroSMulDivisors R B] :
NoZeroSMulDivisors R A := by
refine
Function.Injective.noZeroSMulDivisors _ (IsIntegralClosure.algebraMap_injective A R B)
(map_zero _) fun _ _ => ?_
simp only [Algebra.algebraMap_eq_smul_one, IsScalarTower.smul_assoc]
variable {R} (A) {B} | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | noZeroSMulDivisors | null |
noncomputable mk' (x : B) (hx : IsIntegral R x) : A :=
Classical.choose (isIntegral_iff.mp hx)
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | mk' | If `x : B` is integral over `R`, then it is an element of the integral closure of `R` in `B`. |
algebraMap_mk' (x : B) (hx : IsIntegral R x) : algebraMap A B (mk' A x hx) = x :=
Classical.choose_spec (isIntegral_iff.mp hx)
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | algebraMap_mk' | null |
mk'_one (h : IsIntegral R (1 : B) := isIntegral_one) : mk' A 1 h = 1 :=
algebraMap_injective A R B <| by rw [algebraMap_mk', RingHom.map_one]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | mk'_one | null |
mk'_zero (h : IsIntegral R (0 : B) := isIntegral_zero) : mk' A 0 h = 0 :=
algebraMap_injective A R B <| by rw [algebraMap_mk', RingHom.map_zero]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | mk'_zero | null |
mk'_add (x y : B) (hx : IsIntegral R x) (hy : IsIntegral R y) :
mk' A (x + y) (hx.add hy) = mk' A x hx + mk' A y hy :=
algebraMap_injective A R B <| by simp only [algebraMap_mk', RingHom.map_add]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | mk'_add | null |
mk'_mul (x y : B) (hx : IsIntegral R x) (hy : IsIntegral R y) :
mk' A (x * y) (hx.mul hy) = mk' A x hx * mk' A y hy :=
algebraMap_injective A R B <| by simp only [algebraMap_mk', RingHom.map_mul]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | mk'_mul | null |
mk'_algebraMap [Algebra R A] [IsScalarTower R A B] (x : R)
(h : IsIntegral R (algebraMap R B x) := isIntegral_algebraMap) :
IsIntegralClosure.mk' A (algebraMap R B x) h = algebraMap R A x :=
algebraMap_injective A R B <| by rw [algebraMap_mk', ← IsScalarTower.algebraMap_apply] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | mk'_algebraMap | null |
isField [Algebra R A] [IsScalarTower R A B] [IsDomain A] (hR : IsField R) :
IsField A :=
have := IsIntegralClosure.isIntegral_algebra R (A := A) B
isField_of_isIntegral_of_isField' hR | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | isField | The integral closure of a field in a commutative domain is always a field. |
noncomputable lift : S →ₐ[R] A where
toFun x := mk' A (algebraMap S B x) (IsIntegral.algebraMap
(Algebra.IsIntegral.isIntegral (R := R) x))
map_one' := by simp only [RingHom.map_one, mk'_one]
map_zero' := by simp only [RingHom.map_zero, mk'_zero]
map_add' x y := by simp_rw [← mk'_add, map_add]
map_mul' x y := by simp_rw [← mk'_mul, RingHom.map_mul]
commutes' x := by simp_rw [← IsScalarTower.algebraMap_apply, mk'_algebraMap]
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | lift | If `B / S / R` is a tower of ring extensions where `S` is integral over `R`,
then `S` maps (uniquely) into an integral closure `B / A / R`. |
algebraMap_lift (x : S) : algebraMap A B (lift R A B x) = algebraMap S B x :=
algebraMap_mk' A (algebraMap S B x) (IsIntegral.algebraMap
(Algebra.IsIntegral.isIntegral (R := R) x)) | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | algebraMap_lift | null |
noncomputable equiv : A ≃ₐ[R] A' :=
AlgEquiv.ofAlgHom
(lift R A' B (isIntegral := isIntegral_algebra R B))
(lift R A B (isIntegral := isIntegral_algebra R B))
(by ext x; apply algebraMap_injective A' R B; simp)
(by ext x; apply algebraMap_injective A R B; simp)
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | equiv | Integral closures are all isomorphic to each other. |
algebraMap_equiv (x : A) : algebraMap A' B (equiv R A B A' x) = algebraMap A B x :=
algebraMap_lift R A' B (isIntegral := isIntegral_algebra R B) x | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | algebraMap_equiv | null |
isIntegral_trans [Algebra.IsIntegral R A] (x : B) (hx : IsIntegral A x) :
IsIntegral R x := by
rcases hx with ⟨p, pmonic, hp⟩
let S := adjoin R (p.coeffs : Set A)
have : Module.Finite R S := ⟨(Subalgebra.toSubmodule S).fg_top.mpr <|
fg_adjoin_of_finite p.coeffs.finite_toSet fun a _ ↦ Algebra.IsIntegral.isIntegral a⟩
let p' : S[X] := p.toSubring S.toSubring subset_adjoin
have hSx : IsIntegral S x := ⟨p', (p.monic_toSubring _ _).mpr pmonic, by
rw [IsScalarTower.algebraMap_eq S A B, ← eval₂_map]
convert hp; apply p.map_toSubring S.toSubring⟩
let Sx := Subalgebra.toSubmodule (adjoin S {x})
let MSx : Module S Sx := SMulMemClass.toModule _ -- the next line times out without this
have : Module.Finite S Sx := ⟨(Submodule.fg_top _).mpr hSx.fg_adjoin_singleton⟩
refine .of_mem_of_fg ((adjoin S {x}).restrictScalars R) ?_ _
((Subalgebra.mem_restrictScalars R).mpr <| subset_adjoin rfl)
rw [← Submodule.fg_top, ← Module.finite_def]
letI : SMul S Sx := { MSx with } -- need this even though MSx is there
have : IsScalarTower R S Sx :=
Submodule.isScalarTower Sx -- Lean looks for `Module A Sx` without this
exact Module.Finite.trans S Sx
variable (A) in | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | isIntegral_trans | If A is an R-algebra all of whose elements are integral over R,
and x is an element of an A-algebra that is integral over A, then x is integral over R. |
protected Algebra.IsIntegral.trans
[Algebra.IsIntegral R A] [Algebra.IsIntegral A B] : Algebra.IsIntegral R B :=
⟨fun x ↦ isIntegral_trans x (Algebra.IsIntegral.isIntegral (R := A) x)⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | Algebra.IsIntegral.trans | If A is an R-algebra all of whose elements are integral over R,
and B is an A-algebra all of whose elements are integral over A,
then all elements of B are integral over R. |
protected RingHom.IsIntegral.trans
(hf : f.IsIntegral) (hg : g.IsIntegral) : (g.comp f).IsIntegral :=
let _ := f.toAlgebra; let _ := g.toAlgebra; let _ := (g.comp f).toAlgebra
have : IsScalarTower R S T := IsScalarTower.of_algebraMap_eq fun _ ↦ rfl
have : Algebra.IsIntegral R S := ⟨hf⟩
have : Algebra.IsIntegral S T := ⟨hg⟩
have : Algebra.IsIntegral R T := Algebra.IsIntegral.trans S
Algebra.IsIntegral.isIntegral | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | RingHom.IsIntegral.trans | null |
IsIntegralClosure.tower_top {B C : Type*} [CommSemiring C] [CommRing B]
[Algebra R B] [Algebra A B] [Algebra C B] [IsScalarTower R A B]
[IsIntegralClosure C R B] [Algebra.IsIntegral R A] :
IsIntegralClosure C A B :=
⟨IsIntegralClosure.algebraMap_injective _ R _,
fun hx => (IsIntegralClosure.isIntegral_iff).mp (isIntegral_trans (R := R) _ hx),
fun hx => ((IsIntegralClosure.isIntegral_iff (R := R)).mpr hx).tower_top⟩ | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | IsIntegralClosure.tower_top | If `R → A → B` is an algebra tower, `C` is the integral closure of `R` in `B`
and `A` is integral over `R`, then `C` is the integral closure of `A` in `B`. |
RingHom.isIntegral_of_surjective (hf : Function.Surjective f) : f.IsIntegral :=
fun x ↦ (hf x).recOn fun _y hy ↦ hy ▸ f.isIntegralElem_map | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | RingHom.isIntegral_of_surjective | null |
IsIntegral.tower_bot (H : Function.Injective (algebraMap A B)) {x : A}
(h : IsIntegral R (algebraMap A B x)) : IsIntegral R x :=
(isIntegral_algHom_iff (IsScalarTower.toAlgHom R A B) H).mp h
nonrec theorem RingHom.IsIntegral.tower_bot (hg : Function.Injective g)
(hfg : (g.comp f).IsIntegral) : f.IsIntegral :=
letI := f.toAlgebra; letI := g.toAlgebra; letI := (g.comp f).toAlgebra
haveI : IsScalarTower R S T := IsScalarTower.of_algebraMap_eq fun _ ↦ rfl
fun x ↦ IsIntegral.tower_bot hg (hfg (g x))
variable (T) in | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | IsIntegral.tower_bot | If `R → A → B` is an algebra tower with `A → B` injective,
then if the entire tower is an integral extension so is `R → A` |
Algebra.IsIntegral.tower_bot [Algebra R S] [Algebra R T] [Algebra S T]
[NoZeroSMulDivisors S T] [Nontrivial T] [IsScalarTower R S T]
[h : Algebra.IsIntegral R T] : Algebra.IsIntegral R S where
isIntegral := by
apply RingHom.IsIntegral.tower_bot (algebraMap R S) (algebraMap S T)
(FaithfulSMul.algebraMap_injective S T)
rw [← IsScalarTower.algebraMap_eq R S T]
exact h.isIntegral | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | Algebra.IsIntegral.tower_bot | Let `T / S / R` be a tower of algebras, `T` is non-trivial and is a torsion free `S`-module,
then if `T` is an integral `R`-algebra, then `S` is an integral `R`-algebra. |
IsIntegral.tower_bot_of_field {R A B : Type*} [CommRing R] [Field A]
[Ring B] [Nontrivial B] [Algebra R A] [Algebra A B] [Algebra R B] [IsScalarTower R A B]
{x : A} (h : IsIntegral R (algebraMap A B x)) : IsIntegral R x :=
h.tower_bot (algebraMap A B).injective | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | IsIntegral.tower_bot_of_field | null |
RingHom.isIntegralElem.of_comp {x : T} (h : (g.comp f).IsIntegralElem x) :
g.IsIntegralElem x :=
let ⟨p, hp, hp'⟩ := h
⟨p.map f, hp.map f, by rwa [← eval₂_map] at hp'⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | RingHom.isIntegralElem.of_comp | null |
RingHom.IsIntegral.tower_top (h : (g.comp f).IsIntegral) : g.IsIntegral :=
fun x ↦ RingHom.isIntegralElem.of_comp f g (h x)
variable (R) in | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | RingHom.IsIntegral.tower_top | null |
Algebra.IsIntegral.tower_top [Algebra R S] [Algebra R T] [Algebra S T] [IsScalarTower R S T]
[h : Algebra.IsIntegral R T] : Algebra.IsIntegral S T where
isIntegral := by
apply RingHom.IsIntegral.tower_top (algebraMap R S) (algebraMap S T)
rw [← IsScalarTower.algebraMap_eq R S T]
exact h.isIntegral | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | Algebra.IsIntegral.tower_top | Let `T / S / R` be a tower of algebras, `T` is an integral `R`-algebra, then it is integral
as an `S`-algebra. |
RingHom.IsIntegral.quotient {I : Ideal S} (hf : f.IsIntegral) :
(Ideal.quotientMap I f le_rfl).IsIntegral := by
rintro ⟨x⟩
obtain ⟨p, p_monic, hpx⟩ := hf x
refine ⟨p.map (Ideal.Quotient.mk _), p_monic.map _, ?_⟩
simpa only [hom_eval₂, eval₂_map] using congr_arg (Ideal.Quotient.mk I) hpx | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | RingHom.IsIntegral.quotient | null |
Algebra.IsIntegral.quotient {I : Ideal A} [Algebra.IsIntegral R A] :
Algebra.IsIntegral (R ⧸ I.comap (algebraMap R A)) (A ⧸ I) :=
⟨RingHom.IsIntegral.quotient (algebraMap R A) Algebra.IsIntegral.isIntegral⟩ | instance | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | Algebra.IsIntegral.quotient | null |
isIntegral_quotientMap_iff {I : Ideal S} :
(Ideal.quotientMap I f le_rfl).IsIntegral ↔
((Ideal.Quotient.mk I).comp f : R →+* S ⧸ I).IsIntegral := by
let g := Ideal.Quotient.mk (I.comap f)
have : (Ideal.quotientMap I f le_rfl).comp g = (Ideal.Quotient.mk I).comp f :=
Ideal.quotientMap_comp_mk le_rfl
refine ⟨fun h => ?_, fun h => RingHom.IsIntegral.tower_top g _ (this ▸ h)⟩
refine this ▸ RingHom.IsIntegral.trans g (Ideal.quotientMap I f le_rfl) ?_ h
exact g.isIntegral_of_surjective Ideal.Quotient.mk_surjective
variable {R S : Type*} [CommRing R] [CommRing S] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | isIntegral_quotientMap_iff | null |
RingHom.IsIntegral.isLocalHom {f : R →+* S} (hf : f.IsIntegral)
(inj : Function.Injective f) : IsLocalHom f where
map_nonunit a ha := by
obtain ⟨p, p_monic, hp⟩ := hf (ha.unit⁻¹ : _)
refine isUnit_of_mul_eq_one _ (-p.reverse.divX.eval a) ?_
nth_rewrite 1 [mul_neg, ← eval_X (x := a), ← eval_mul, ← p_monic, ← coeff_zero_reverse,
← add_eq_zero_iff_neg_eq, ← eval_C (a := p.reverse.coeff 0), ← eval_add, X_mul_divX_add,
← (injective_iff_map_eq_zero' _).mp inj, ← eval₂_hom]
rwa [← eval₂_reverse_eq_zero_iff] at hp
variable [Algebra R S] [Algebra.IsIntegral R S]
variable (R S) in | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | RingHom.IsIntegral.isLocalHom | null |
Algebra.IsIntegral.isLocalHom [FaithfulSMul R S] : IsLocalHom (algebraMap R S) :=
(algebraMap_isIntegral_iff.mpr ‹_›).isLocalHom (FaithfulSMul.algebraMap_injective R S) | instance | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | Algebra.IsIntegral.isLocalHom | null |
isField_of_isIntegral_of_isField (hRS : Function.Injective (algebraMap R S))
(hS : IsField S) : IsField R :=
have := (faithfulSMul_iff_algebraMap_injective R S).mpr hRS
IsLocalHom.isField hRS hS | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | isField_of_isIntegral_of_isField | If the integral extension `R → S` is injective, and `S` is a field, then `R` is also a field. |
Algebra.IsIntegral.isField_iff_isField [IsDomain S]
(hRS : Function.Injective (algebraMap R S)) : IsField R ↔ IsField S :=
⟨isField_of_isIntegral_of_isField', isField_of_isIntegral_of_isField hRS⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | Algebra.IsIntegral.isField_iff_isField | null |
integralClosure_idem {R A : Type*} [CommRing R] [CommRing A] [Algebra R A] :
integralClosure (integralClosure R A) A = ⊥ :=
letI := (integralClosure R A).algebra
eq_bot_iff.2 fun x hx ↦ Algebra.mem_bot.2
⟨⟨x, isIntegral_trans (A := integralClosure R A) x hx⟩, rfl⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | integralClosure_idem | null |
roots_mem_integralClosure {f : R[X]} (hf : f.Monic) {a : S}
(ha : a ∈ f.aroots S) : a ∈ integralClosure R S :=
⟨f, hf, (eval₂_eq_eval_map _).trans <| (mem_roots <| (hf.map _).ne_zero).1 ha⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.IntegralClosure.Algebra.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Defs",
"Mathlib.RingTheory.Polynomial.IntegralNormalization",
"Mathlib.RingTheory.Polynomial.ScaleRoots",
"Mathlib.RingTheory.Ten... | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean | roots_mem_integralClosure | null |
IsIntegralClosure (A R B : Type*) [CommRing R] [CommSemiring A] [CommRing B] [Algebra R B]
[Algebra A B] : Prop where
algebraMap_injective (A R B) : Function.Injective (algebraMap A B)
isIntegral_iff : ∀ {x : B}, IsIntegral R x ↔ ∃ y, algebraMap A B y = x | class | RingTheory | [
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Defs"
] | Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Defs.lean | IsIntegralClosure | `IsIntegralClosure A R B` is the characteristic predicate stating `A` is
the integral closure of `R` in `B`,
i.e. that an element of `B` is integral over `R` iff it is an element of (the image of) `A`. |
protected IsLocalization.AtPrime :=
IsLocalization P.primeCompl S | abbrev | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | IsLocalization.AtPrime | Given a prime ideal `P`, the typeclass `IsLocalization.AtPrime S P` states that `S` is
isomorphic to the localization of `R` at the complement of `P`. |
protected Localization.AtPrime :=
Localization P.primeCompl | abbrev | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | Localization.AtPrime | Given a prime ideal `P`, `Localization.AtPrime P` is a localization of
`R` at the complement of `P`, as a quotient type. |
AtPrime.nontrivial [IsLocalization.AtPrime S P] : Nontrivial S :=
nontrivial_of_ne (0 : S) 1 fun hze => by
rw [← (algebraMap R S).map_one, ← (algebraMap R S).map_zero] at hze
obtain ⟨t, ht⟩ := (eq_iff_exists P.primeCompl S).1 hze
have htz : (t : R) = 0 := by simpa using ht.symm
exact t.2 (htz.symm ▸ P.zero_mem : ↑t ∈ P)
@[deprecated (since := "2025-07-31")] alias AtPrime.Nontrivial := IsLocalization.AtPrime.nontrivial | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | AtPrime.nontrivial | null |
AtPrime.isLocalRing [IsLocalization.AtPrime S P] : IsLocalRing S :=
letI := AtPrime.nontrivial S P -- Can't be a local instance because we can't figure out `P`.
IsLocalRing.of_nonunits_add
(by
intro x y hx hy hu
obtain ⟨z, hxyz⟩ := isUnit_iff_exists_inv.1 hu
have : ∀ {r : R} {s : P.primeCompl}, mk' S r s ∈ nonunits S → r ∈ P := fun {r s} =>
not_imp_comm.1 fun nr => isUnit_iff_exists_inv.2 ⟨mk' S ↑s (⟨r, nr⟩ : P.primeCompl),
mk'_mul_mk'_eq_one' _ _ <| show r ∈ P.primeCompl from nr⟩
rcases mk'_surjective P.primeCompl x with ⟨rx, sx, hrx⟩
rcases mk'_surjective P.primeCompl y with ⟨ry, sy, hry⟩
rcases mk'_surjective P.primeCompl z with ⟨rz, sz, hrz⟩
rw [← hrx, ← hry, ← hrz, ← mk'_add, ← mk'_mul, ← mk'_self S P.primeCompl.one_mem] at hxyz
rw [← hrx] at hx
rw [← hry] at hy
obtain ⟨t, ht⟩ := IsLocalization.eq.1 hxyz
simp only [mul_one, one_mul, Submonoid.coe_mul] at ht
suffices (t : R) * (sx * sy * sz) ∈ P from
not_or_intro (mt hp.mem_or_mem <| not_or_intro sx.2 sy.2) sz.2
(hp.mem_or_mem <| (hp.mem_or_mem this).resolve_left t.2)
rw [← ht]
exact
P.mul_mem_left _ <| P.mul_mem_right _ <|
P.add_mem (P.mul_mem_right _ <| this hx) <| P.mul_mem_right _ <| this hy) | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | AtPrime.isLocalRing | null |
AtPrime.isLocalRing : IsLocalRing (Localization P.primeCompl) :=
IsLocalization.AtPrime.isLocalRing (Localization P.primeCompl) P | instance | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | AtPrime.isLocalRing | The localization of `R` at the complement of a prime ideal is a local ring. |
_root_.IsLocalization.AtPrime.faithfulSMul (R : Type*) [CommRing R] [NoZeroDivisors R]
[Algebra R S] (P : Ideal R) [hp : P.IsPrime] [IsLocalization.AtPrime S P] :
FaithfulSMul R S := by
rw [faithfulSMul_iff_algebraMap_injective, IsLocalization.injective_iff_isRegular P.primeCompl]
exact fun ⟨_, h⟩ ↦ isRegular_of_ne_zero <| by aesop | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | _root_.IsLocalization.AtPrime.faithfulSMul | null |
isDomain_of_local_atPrime {P : Ideal A} (_ : P.IsPrime) :
IsDomain (Localization.AtPrime P) :=
isDomain_localization P.primeCompl_le_nonZeroDivisors | instance | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | isDomain_of_local_atPrime | The localization of an integral domain at the complement of a prime ideal is an integral domain. |
@[simps!]
orderIsoOfPrime : { p : Ideal S // p.IsPrime } ≃o { p : Ideal R // p.IsPrime ∧ p ≤ I } :=
(IsLocalization.orderIsoOfPrime I.primeCompl S).trans <| .setCongr _ _ <| show setOf _ = setOf _
by ext; simp [Ideal.primeCompl, ← le_compl_iff_disjoint_left] | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | orderIsoOfPrime | The prime ideals in the localization of a commutative ring at a prime ideal I are in
order-preserving bijection with the prime ideals contained in I. |
@[simps!] primeSpectrumOrderIso : PrimeSpectrum S ≃o Set.Iic (⟨I, hI⟩ : PrimeSpectrum R) :=
(PrimeSpectrum.equivSubtype S).trans <| (orderIsoOfPrime S I).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⟩ | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | primeSpectrumOrderIso | The prime spectrum of the localization of a commutative ring R at a prime ideal I are in
order-preserving bijection with the interval (-∞, I] in the prime spectrum of R. |
isUnit_to_map_iff (x : R) : IsUnit ((algebraMap R S) x) ↔ x ∈ I.primeCompl :=
⟨fun h hx =>
(isPrime_of_isPrime_disjoint I.primeCompl S I hI disjoint_compl_left).ne_top <|
(Ideal.map (algebraMap R S) I).eq_top_of_isUnit_mem (Ideal.mem_map_of_mem _ hx) h,
fun h => map_units S ⟨x, h⟩⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | isUnit_to_map_iff | null |
to_map_mem_maximal_iff (x : R) (h : IsLocalRing S := isLocalRing S I) :
algebraMap R S x ∈ IsLocalRing.maximalIdeal S ↔ x ∈ I :=
not_iff_not.mp <| by
simpa only [IsLocalRing.mem_maximalIdeal, mem_nonunits_iff, Classical.not_not] using
isUnit_to_map_iff S I x | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | to_map_mem_maximal_iff | null |
comap_maximalIdeal (h : IsLocalRing S := isLocalRing S I) :
(IsLocalRing.maximalIdeal S).comap (algebraMap R S) = I :=
Ideal.ext fun x => by simpa only [Ideal.mem_comap] using to_map_mem_maximal_iff _ I x | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | comap_maximalIdeal | null |
isUnit_mk'_iff (x : R) (y : I.primeCompl) : IsUnit (mk' S x y) ↔ x ∈ I.primeCompl :=
⟨fun h hx => mk'_mem_iff.mpr ((to_map_mem_maximal_iff S I x).mpr hx) h, fun h =>
isUnit_iff_exists_inv.mpr ⟨mk' S ↑y ⟨x, h⟩, mk'_mul_mk'_eq_one ⟨x, h⟩ y⟩⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | isUnit_mk'_iff | null |
mk'_mem_maximal_iff (x : R) (y : I.primeCompl) (h : IsLocalRing S := isLocalRing S I) :
mk' S x y ∈ IsLocalRing.maximalIdeal S ↔ x ∈ I :=
not_iff_not.mp <| by
simpa only [IsLocalRing.mem_maximalIdeal, mem_nonunits_iff, Classical.not_not] using
isUnit_mk'_iff S I x y | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | mk'_mem_maximal_iff | null |
AtPrime.comap_maximalIdeal :
Ideal.comap (algebraMap R (Localization.AtPrime I))
(IsLocalRing.maximalIdeal (Localization I.primeCompl)) =
I :=
IsLocalization.AtPrime.comap_maximalIdeal _ _ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | AtPrime.comap_maximalIdeal | The unique maximal ideal of the localization at `I.primeCompl` lies over the ideal `I`. |
AtPrime.map_eq_maximalIdeal :
Ideal.map (algebraMap R (Localization.AtPrime I)) I =
IsLocalRing.maximalIdeal (Localization I.primeCompl) := by
convert congr_arg (Ideal.map _) AtPrime.comap_maximalIdeal.symm
rw [map_comap I.primeCompl] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | AtPrime.map_eq_maximalIdeal | The image of `I` in the localization at `I.primeCompl` is a maximal ideal, and in particular
it is the unique maximal ideal given by the local ring structure `AtPrime.isLocalRing` |
AtPrime.eq_maximalIdeal_iff_comap_eq {J : Ideal (Localization.AtPrime I)} :
Ideal.comap (algebraMap R (Localization.AtPrime I)) J = I ↔
J = IsLocalRing.maximalIdeal (Localization.AtPrime I) where
mp h := le_antisymm (IsLocalRing.le_maximalIdeal (fun hJ ↦ (hI.ne_top (h.symm ▸ hJ ▸ rfl)))) <| by
simpa [← AtPrime.map_eq_maximalIdeal, ← h] using Ideal.map_comap_le
mpr h := h.symm ▸ AtPrime.comap_maximalIdeal | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | AtPrime.eq_maximalIdeal_iff_comap_eq | null |
le_comap_primeCompl_iff {J : Ideal P} [J.IsPrime] {f : R →+* P} :
I.primeCompl ≤ J.primeCompl.comap f ↔ J.comap f ≤ I :=
⟨fun h x hx => by
contrapose! hx
exact h hx,
fun h _ hx hfxJ => hx (h hfxJ)⟩
variable (I) | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | le_comap_primeCompl_iff | null |
noncomputable localRingHom (J : Ideal P) [J.IsPrime] (f : R →+* P) (hIJ : I = J.comap f) :
Localization.AtPrime I →+* Localization.AtPrime J :=
IsLocalization.map (Localization.AtPrime J) f (le_comap_primeCompl_iff.mpr (ge_of_eq hIJ)) | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | localRingHom | For a ring hom `f : R →+* S` and a prime ideal `J` in `S`, the induced ring hom from the
localization of `R` at `J.comap f` to the localization of `S` at `J`.
To make this definition more flexible, we allow any ideal `I` of `R` as input, together with a proof
that `I = J.comap f`. This can be useful when `I` is not definitionally equal to `J.comap f`. |
localRingHom_to_map (J : Ideal P) [J.IsPrime] (f : R →+* P) (hIJ : I = J.comap f)
(x : R) : localRingHom I J f hIJ (algebraMap _ _ x) = algebraMap _ _ (f x) :=
map_eq _ _ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | localRingHom_to_map | null |
localRingHom_mk' (J : Ideal P) [J.IsPrime] (f : R →+* P) (hIJ : I = J.comap f) (x : R)
(y : I.primeCompl) :
localRingHom I J f hIJ (IsLocalization.mk' _ x y) =
IsLocalization.mk' (Localization.AtPrime J) (f x)
(⟨f y, le_comap_primeCompl_iff.mpr (ge_of_eq hIJ) y.2⟩ : J.primeCompl) :=
map_mk' _ _ _
@[instance] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | localRingHom_mk' | null |
isLocalHom_localRingHom (J : Ideal P) [hJ : J.IsPrime] (f : R →+* P)
(hIJ : I = J.comap f) : IsLocalHom (localRingHom I J f hIJ) :=
IsLocalHom.mk fun x hx => by
rcases IsLocalization.mk'_surjective I.primeCompl x with ⟨r, s, rfl⟩
rw [localRingHom_mk'] at hx
rw [AtPrime.isUnit_mk'_iff] at hx ⊢
exact fun hr => hx ((SetLike.ext_iff.mp hIJ r).mp hr) | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | isLocalHom_localRingHom | null |
localRingHom_unique (J : Ideal P) [J.IsPrime] (f : R →+* P) (hIJ : I = J.comap f)
{j : Localization.AtPrime I →+* Localization.AtPrime J}
(hj : ∀ x : R, j (algebraMap _ _ x) = algebraMap _ _ (f x)) : localRingHom I J f hIJ = j :=
map_unique _ _ hj
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | localRingHom_unique | null |
localRingHom_id : localRingHom I I (RingHom.id R) (Ideal.comap_id I).symm = RingHom.id _ :=
localRingHom_unique _ _ _ _ fun _ => rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | localRingHom_id | null |
localRingHom_comp {S : Type*} [CommSemiring S] (J : Ideal S) [hJ : J.IsPrime] (K : Ideal P)
[hK : K.IsPrime] (f : R →+* S) (hIJ : I = J.comap f) (g : S →+* P) (hJK : J = K.comap g) :
localRingHom I K (g.comp f) (by rw [hIJ, hJK, Ideal.comap_comap f g]) =
(localRingHom J K g hJK).comp (localRingHom I J f hIJ) :=
localRingHom_unique _ _ _ _ fun r => by
simp only [Function.comp_apply, RingHom.coe_comp, localRingHom_to_map] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | localRingHom_comp | null |
noncomputable mapPiEvalRingHom :
Localization.AtPrime (I.comap <| Pi.evalRingHom R i) →+* Localization.AtPrime I :=
localRingHom _ _ _ rfl | abbrev | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | mapPiEvalRingHom | `Localization.localRingHom` specialized to a projection homomorphism from a product ring. |
mapPiEvalRingHom_bijective : Function.Bijective (mapPiEvalRingHom I) :=
Localization.mapPiEvalRingHom_bijective _ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | mapPiEvalRingHom_bijective | null |
mapPiEvalRingHom_comp_algebraMap :
(mapPiEvalRingHom I).comp (algebraMap _ _) = (algebraMap _ _).comp (Pi.evalRingHom R i) :=
IsLocalization.map_comp _ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | mapPiEvalRingHom_comp_algebraMap | null |
mapPiEvalRingHom_algebraMap_apply {r : Π i, R i} :
mapPiEvalRingHom I (algebraMap _ _ r) = algebraMap _ _ (r i) :=
localRingHom_to_map .. | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | mapPiEvalRingHom_algebraMap_apply | null |
Ideal.isPrime_map_of_isLocalizationAtPrime {p : Ideal R} [p.IsPrime] (hpq : p ≤ q) :
(p.map (algebraMap R S)).IsPrime := by
have disj : Disjoint (q.primeCompl : Set R) p := by
simp [Ideal.primeCompl, ← le_compl_iff_disjoint_left, hpq]
apply IsLocalization.isPrime_of_isPrime_disjoint q.primeCompl _ p (by simpa) disj | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | Ideal.isPrime_map_of_isLocalizationAtPrime | null |
Ideal.under_map_of_isLocalizationAtPrime {p : Ideal R} [p.IsPrime] (hpq : p ≤ q) :
(p.map (algebraMap R S)).under R = p := by
have disj : Disjoint (q.primeCompl : Set R) p := by
simp [Ideal.primeCompl, ← le_compl_iff_disjoint_left, hpq]
exact IsLocalization.comap_map_of_isPrime_disjoint _ _ p (by simpa) disj | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | Ideal.under_map_of_isLocalizationAtPrime | null |
IsLocalization.subsingleton_primeSpectrum_of_mem_minimalPrimes
{R : Type*} [CommSemiring R] (p : Ideal R) (hp : p ∈ minimalPrimes R)
(S : Type*) [CommSemiring S] [Algebra R S] [IsLocalization.AtPrime S p (hp := hp.1.1)] :
Subsingleton (PrimeSpectrum S) :=
have := hp.1.1
have : Unique (Set.Iic (⟨p, hp.1.1⟩ : PrimeSpectrum R)) := ⟨⟨⟨p, hp.1.1⟩, by exact
fun ⦃x⦄ a ↦ a⟩, fun i ↦ Subtype.ext <| PrimeSpectrum.ext <|
(minimalPrimes_eq_minimals (R := R) ▸ hp).eq_of_le i.1.2 i.2⟩
(IsLocalization.AtPrime.primeSpectrumOrderIso S p).subsingleton | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic"
] | Mathlib/RingTheory/Localization/AtPrime/Basic.lean | IsLocalization.subsingleton_primeSpectrum_of_mem_minimalPrimes | null |
noncomputable Localization.awayEquivAdjoin (r : R) : Away r ≃ₐ[R] AdjoinRoot (C r * X - 1) :=
AlgEquiv.ofAlgHom
{ awayLift _ r _ with
commutes' :=
IsLocalization.Away.lift_eq r (isUnit_of_mul_eq_one _ _ <| root_isInv r) }
(liftHom _ (IsLocalization.Away.invSelf r) <| by
simp only [map_sub, map_mul, aeval_C, aeval_X, IsLocalization.Away.mul_invSelf, aeval_one,
sub_self])
(Subsingleton.elim _ _)
(Subsingleton.elim (h := IsLocalization.algHom_subsingleton (Submonoid.powers r)) _ _) | def | RingTheory | [
"Mathlib.RingTheory.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/Localization/Away/AdjoinRoot.lean | Localization.awayEquivAdjoin | The `R`-`AlgEquiv` between the localization of `R` away from `r` and
`R` with an inverse of `r` adjoined. |
IsLocalization.adjoin_inv (r : R) : IsLocalization.Away r (AdjoinRoot <| C r * X - 1) :=
IsLocalization.isLocalization_of_algEquiv _ (Localization.awayEquivAdjoin r) | theorem | RingTheory | [
"Mathlib.RingTheory.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/Localization/Away/AdjoinRoot.lean | IsLocalization.adjoin_inv | null |
IsLocalization.Away.finitePresentation (r : R) {S} [CommRing S] [Algebra R S]
[IsLocalization.Away r S] : Algebra.FinitePresentation R S :=
(AdjoinRoot.finitePresentation _).equiv <|
(Localization.awayEquivAdjoin r).symm.trans <| IsLocalization.algEquiv (Submonoid.powers r) _ _ | theorem | RingTheory | [
"Mathlib.RingTheory.AdjoinRoot",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/Localization/Away/AdjoinRoot.lean | IsLocalization.Away.finitePresentation | null |
Away (S : Type*) [CommSemiring S] [Algebra R S] :=
IsLocalization (Submonoid.powers x) S | abbrev | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | Away | Given `x : R`, the typeclass `IsLocalization.Away x S` states that `S` is
isomorphic to the localization of `R` at the submonoid generated by `x`.
See `IsLocalization.Away.mk` for a specialized constructor. |
noncomputable invSelf : S :=
mk' S (1 : R) ⟨x, Submonoid.mem_powers _⟩
@[simp] | def | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | invSelf | Given `x : R` and a localization map `F : R →+* S` away from `x`, `invSelf` is `(F x)⁻¹`. |
mul_invSelf : algebraMap R S x * invSelf x = 1 := by
convert IsLocalization.mk'_mul_mk'_eq_one (M := Submonoid.powers x) (S := S) _ 1
symm
apply IsLocalization.mk'_one | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | mul_invSelf | null |
noncomputable sec (s : S) : R × ℕ :=
⟨(IsLocalization.sec (Submonoid.powers x) s).1,
(IsLocalization.sec (Submonoid.powers x) s).2.property.choose⟩ | def | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | sec | For `s : S` with `S` being the localization of `R` away from `x`,
this is a choice of `(r, n) : R × ℕ` such that `s * algebraMap R S (x ^ n) = algebraMap R S r`. |
sec_spec (s : S) : s * (algebraMap R S) (x ^ (IsLocalization.Away.sec x s).2) =
algebraMap R S (IsLocalization.Away.sec x s).1 := by
simp only [IsLocalization.Away.sec, ← IsLocalization.sec_spec]
congr
exact (IsLocalization.sec (Submonoid.powers x) s).2.property.choose_spec | lemma | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | sec_spec | null |
algebraMap_pow_isUnit (n : ℕ) : IsUnit (algebraMap R S x ^ n) :=
IsUnit.pow _ <| IsLocalization.map_units _ (⟨x, 1, by simp⟩ : Submonoid.powers x) | lemma | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | algebraMap_pow_isUnit | null |
algebraMap_isUnit : IsUnit (algebraMap R S x) :=
IsLocalization.map_units _ (⟨x, 1, by simp⟩ : Submonoid.powers x) | lemma | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | algebraMap_isUnit | null |
associated_sec_fst (s : S) :
Associated (algebraMap R S (IsLocalization.Away.sec x s).1) s := by
rw [← IsLocalization.Away.sec_spec, map_pow]
exact associated_mul_unit_left _ _ <| .pow _ <| IsLocalization.Away.algebraMap_isUnit _ | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | associated_sec_fst | null |
algebraMap_isUnit_iff {y : R} : IsUnit (algebraMap R S y) ↔ ∃ n, y ∣ x ^ n :=
(IsLocalization.algebraMap_isUnit_iff <| .powers x).trans <| by simp [Submonoid.mem_powers_iff] | lemma | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | algebraMap_isUnit_iff | null |
surj (z : S) : ∃ (n : ℕ) (a : R), z * algebraMap R S x ^ n = algebraMap R S a := by
obtain ⟨⟨a, ⟨-, n, rfl⟩⟩, h⟩ := IsLocalization.surj (Submonoid.powers x) z
use n, a
simpa using h | lemma | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | surj | null |
exists_of_eq {a b : R} (h : algebraMap R S a = algebraMap R S b) :
∃ (n : ℕ), x ^ n * a = x ^ n * b := by
obtain ⟨⟨-, n, rfl⟩, hx⟩ := IsLocalization.exists_of_eq (M := Submonoid.powers x) h
use n | lemma | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | exists_of_eq | null |
mk (r : R) (map_unit : IsUnit (algebraMap R S r))
(surj : ∀ s, ∃ (n : ℕ) (a : R), s * algebraMap R S r ^ n = algebraMap R S a)
(exists_of_eq : ∀ a b, algebraMap R S a = algebraMap R S b → ∃ (n : ℕ), r ^ n * a = r ^ n * b) :
IsLocalization.Away r S where
map_units := by
rintro ⟨-, n, rfl⟩
simp only [map_pow]
exact IsUnit.pow _ map_unit
surj z := by
obtain ⟨n, a, hn⟩ := surj z
use ⟨a, ⟨r ^ n, n, rfl⟩⟩
simpa using hn
exists_of_eq {x y} h := by
obtain ⟨n, hn⟩ := exists_of_eq x y h
use ⟨r ^ n, n, rfl⟩ | lemma | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | mk | Specialized constructor for `IsLocalization.Away`. |
of_associated {r r' : R} (h : Associated r r') [IsLocalization.Away r S] :
IsLocalization.Away r' S := by
obtain ⟨u, rfl⟩ := h
refine mk _ ?_ (fun s ↦ ?_) (fun a b hab ↦ ?_)
· simp [algebraMap_isUnit r, IsUnit.map _ u.isUnit]
· obtain ⟨n, a, hn⟩ := surj r s
use n, a * u ^ n
simp [mul_pow, ← mul_assoc, hn]
· obtain ⟨n, hn⟩ := exists_of_eq r hab
use n
rw [mul_pow, mul_comm (r ^ n), mul_assoc, mul_assoc, hn] | lemma | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | of_associated | null |
iff_of_associated {r r' : R} (h : Associated r r') :
IsLocalization.Away r S ↔ IsLocalization.Away r' S :=
⟨fun _ ↦ IsLocalization.Away.of_associated h, fun _ ↦ IsLocalization.Away.of_associated h.symm⟩ | lemma | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | iff_of_associated | If `r` and `r'` are associated elements of `R`, an `R`-algebra `S`
is the localization of `R` away from `r` if and only of it is the localization of `R` away from
`r'`. |
isUnit_of_dvd {r : R} (h : r ∣ x) : IsUnit (algebraMap R S r) :=
isUnit_of_dvd_unit (map_dvd _ h) (algebraMap_isUnit x)
variable {g : R →+* P} | lemma | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | isUnit_of_dvd | null |
noncomputable lift (hg : IsUnit (g x)) : S →+* P :=
IsLocalization.lift fun y : Submonoid.powers x =>
show IsUnit (g y.1) by
obtain ⟨n, hn⟩ := y.2
rw [← hn, g.map_pow]
exact IsUnit.map (powMonoidHom n : P →* P) hg
@[simp] | def | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | lift | Given `x : R`, a localization map `F : R →+* S` away from `x`, and a map of `CommSemiring`s
`g : R →+* P` such that `g x` is invertible, the homomorphism induced from `S` to `P` sending
`z : S` to `g y * (g x)⁻ⁿ`, where `y : R, n : ℕ` are such that `z = F y * (F x)⁻ⁿ`. |
lift_eq (hg : IsUnit (g x)) (a : R) : lift x hg (algebraMap R S a) = g a :=
IsLocalization.lift_eq _ _
@[simp] | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | lift_eq | null |
lift_comp (hg : IsUnit (g x)) : (lift x hg).comp (algebraMap R S) = g :=
IsLocalization.lift_comp _ | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | lift_comp | null |
noncomputable awayToAwayLeft (y : R) [Algebra R P] [IsLocalization.Away (y * x) P] : S →+* P :=
lift x <| isUnit_of_dvd (y * x) (dvd_mul_left _ _) | def | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | awayToAwayLeft | Given `x y : R` and localizations `S`, `P` away from `x` and `y * x`
respectively, the homomorphism induced from `S` to `P`. |
noncomputable awayToAwayRight (y : R) [Algebra R P] [IsLocalization.Away (x * y) P] : S →+* P :=
lift x <| isUnit_of_dvd (x * y) (dvd_mul_right _ _) | def | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | awayToAwayRight | Given `x y : R` and localizations `S`, `P` away from `x` and `x * y`
respectively, the homomorphism induced from `S` to `P`. |
awayToAwayLeft_eq (y : R) [Algebra R P] [IsLocalization.Away (y * x) P] (a : R) :
awayToAwayLeft x y (algebraMap R S a) = algebraMap R P a :=
lift_eq _ _ _ | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | awayToAwayLeft_eq | null |
awayToAwayRight_eq (y : R) [Algebra R P] [IsLocalization.Away (x * y) P] (a : R) :
awayToAwayRight x y (algebraMap R S a) = algebraMap R P a :=
lift_eq _ _ _
variable (S) (Q : Type*) [CommSemiring Q] [Algebra P Q] | theorem | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | awayToAwayRight_eq | null |
noncomputable map (f : R →+* P) (r : R) [IsLocalization.Away r S]
[IsLocalization.Away (f r) Q] : S →+* Q :=
IsLocalization.map Q f
(show Submonoid.powers r ≤ (Submonoid.powers (f r)).comap f by
rintro x ⟨n, rfl⟩
use n
simp) | def | RingTheory | [
"Mathlib.GroupTheory.MonoidLocalization.Away",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicity"
] | Mathlib/RingTheory/Localization/Away/Basic.lean | map | Given a map `f : R →+* S` and an element `r : R`, we may construct a map `Rᵣ →+* Sᵣ`. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.