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 ⌀ |
|---|---|---|---|---|---|---|
containsIdentities : ContainsIdentities Flat := id | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Ideal.GoingDown"
] | Mathlib/RingTheory/RingHom/Flat.lean | containsIdentities | null |
stableUnderComposition : StableUnderComposition Flat := by
introv R hf hg
exact hf.comp hg | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Ideal.GoingDown"
] | Mathlib/RingTheory/RingHom/Flat.lean | stableUnderComposition | null |
respectsIso : RespectsIso Flat := by
apply stableUnderComposition.respectsIso
introv
exact of_bijective e.bijective | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Ideal.GoingDown"
] | Mathlib/RingTheory/RingHom/Flat.lean | respectsIso | null |
isStableUnderBaseChange : IsStableUnderBaseChange Flat := by
apply IsStableUnderBaseChange.mk respectsIso
introv h
rw [flat_algebraMap_iff] at h ⊢
infer_instance | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Ideal.GoingDown"
] | Mathlib/RingTheory/RingHom/Flat.lean | isStableUnderBaseChange | null |
holdsForLocalizationAway : HoldsForLocalizationAway Flat := by
introv R h
suffices Module.Flat R S by
rw [RingHom.Flat]; convert this; ext; simp_rw [Algebra.smul_def]; rfl
exact IsLocalization.flat _ (Submonoid.powers r) | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Ideal.GoingDown"
] | Mathlib/RingTheory/RingHom/Flat.lean | holdsForLocalizationAway | null |
ofLocalizationSpanTarget : OfLocalizationSpanTarget Flat := by
introv R hsp h
algebraize_only [f]
refine Module.flat_of_isLocalized_span _ _ s hsp _
(fun r ↦ Algebra.linearMap S <| Localization.Away r.1) ?_
dsimp only [RingHom.Flat] at h
convert h; ext
apply Algebra.smul_def | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Ideal.GoingDown"
] | Mathlib/RingTheory/RingHom/Flat.lean | ofLocalizationSpanTarget | null |
propertyIsLocal : PropertyIsLocal Flat where
localizationAwayPreserves := isStableUnderBaseChange.localizationPreserves.away
ofLocalizationSpanTarget := ofLocalizationSpanTarget
ofLocalizationSpan := ofLocalizationSpanTarget.ofLocalizationSpan
(stableUnderComposition.stableUnderCompositionWithLocalizationAway
holdsForLocalizationAway).left
StableUnderCompositionWithLocalizationAwayTarget :=
(stableUnderComposition.stableUnderCompositionWithLocalizationAway
holdsForLocalizationAway).right | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Ideal.GoingDown"
] | Mathlib/RingTheory/RingHom/Flat.lean | propertyIsLocal | Flat is a local property of ring homomorphisms. |
ofLocalizationPrime : OfLocalizationPrime Flat := by
introv R h
algebraize_only [f]
rw [RingHom.Flat]
apply Module.flat_of_isLocalized_maximal S S (fun P ↦ Localization.AtPrime P)
(fun P ↦ Algebra.linearMap S _)
intro P _
algebraize_only [Localization.localRingHom (Ideal.comap f P) P f rfl]
have : IsScalarTower R (Localization.AtPrime (Ideal.comap f P)) (Localization.AtPrime P) :=
.of_algebraMap_eq fun x ↦ (Localization.localRingHom_to_map _ _ _ rfl x).symm
replace h : Module.Flat (Localization.AtPrime (Ideal.comap f P)) (Localization.AtPrime P) := h ..
exact Module.Flat.trans R (Localization.AtPrime <| Ideal.comap f P) (Localization.AtPrime P) | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Ideal.GoingDown"
] | Mathlib/RingTheory/RingHom/Flat.lean | ofLocalizationPrime | null |
localRingHom {f : R →+* S} (hf : f.Flat)
(P : Ideal S) [P.IsPrime] (Q : Ideal R) [Q.IsPrime] (hQP : Q = Ideal.comap f P) :
(Localization.localRingHom Q P f hQP).Flat := by
subst hQP
algebraize [f, Localization.localRingHom (Ideal.comap f P) P f rfl]
have : IsScalarTower R (Localization.AtPrime (Ideal.comap f P)) (Localization.AtPrime P) :=
.of_algebraMap_eq fun x ↦ (Localization.localRingHom_to_map _ _ _ rfl x).symm
rw [RingHom.Flat, Module.flat_iff_of_isLocalization
(S := (Localization.AtPrime (Ideal.comap f P))) (p := (Ideal.comap f P).primeCompl)]
exact Module.Flat.trans R S (Localization.AtPrime P)
open PrimeSpectrum | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Ideal.GoingDown"
] | Mathlib/RingTheory/RingHom/Flat.lean | localRingHom | null |
generalizingMap_comap {f : R →+* S} (hf : f.Flat) : GeneralizingMap (comap f) := by
algebraize [f]
change GeneralizingMap (comap (algebraMap R S))
rw [← Algebra.HasGoingDown.iff_generalizingMap_primeSpectrumComap]
infer_instance | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Localization",
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Ideal.GoingDown"
] | Mathlib/RingTheory/RingHom/Flat.lean | generalizingMap_comap | `Spec S → Spec R` is generalizing if `R →+* S` is flat. |
_root_.RingHom.injective_stableUnderComposition :
RingHom.StableUnderComposition (fun f ↦ Function.Injective f) := by
intro R S T _ _ _ f g hf hg
simp only [RingHom.coe_comp]
exact Function.Injective.comp hg hf | lemma | RingTheory | [
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/RingHom/Injective.lean | _root_.RingHom.injective_stableUnderComposition | null |
_root_.RingHom.injective_respectsIso :
RingHom.RespectsIso (fun f ↦ Function.Injective f) := by
apply RingHom.injective_stableUnderComposition.respectsIso
intro R S _ _ e
exact e.bijective.injective | lemma | RingTheory | [
"Mathlib.RingTheory.RingHomProperties"
] | Mathlib/RingTheory/RingHom/Injective.lean | _root_.RingHom.injective_respectsIso | null |
isIntegral_stableUnderComposition : StableUnderComposition fun f => f.IsIntegral := by
introv R hf hg; exact hf.trans _ _ hg | theorem | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/RingHom/Integral.lean | isIntegral_stableUnderComposition | null |
isIntegral_respectsIso : RespectsIso fun f => f.IsIntegral := by
apply isIntegral_stableUnderComposition.respectsIso
introv x
rw [← e.apply_symm_apply x]
apply RingHom.isIntegralElem_map | theorem | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/RingHom/Integral.lean | isIntegral_respectsIso | null |
isIntegral_isStableUnderBaseChange : IsStableUnderBaseChange fun f => f.IsIntegral := by
refine IsStableUnderBaseChange.mk isIntegral_respectsIso ?_
introv int
rw [algebraMap_isIntegral_iff] at int ⊢
infer_instance
open Polynomial in | theorem | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/RingHom/Integral.lean | isIntegral_isStableUnderBaseChange | null |
isIntegral_ofLocalizationSpan :
OfLocalizationSpan (RingHom.IsIntegral ·) := by
introv R hs H r
letI := f.toAlgebra
change r ∈ (integralClosure R S).toSubmodule
apply Submodule.mem_of_span_eq_top_of_smul_pow_mem _ s hs
rintro ⟨t, ht⟩
letI := (Localization.awayMap f t).toAlgebra
haveI : IsScalarTower R (Localization.Away t) (Localization.Away (f t)) := .of_algebraMap_eq'
(IsLocalization.lift_comp _).symm
have : _root_.IsIntegral (Localization.Away t) (algebraMap S (Localization.Away (f t)) r) :=
H ⟨t, ht⟩ (algebraMap _ _ r)
obtain ⟨⟨_, n, rfl⟩, p, hp, hp'⟩ := this.exists_multiple_integral_of_isLocalization (.powers t)
rw [IsScalarTower.algebraMap_eq R S, Submonoid.smul_def, Algebra.smul_def,
IsScalarTower.algebraMap_apply R S, ← map_mul, ← hom_eval₂,
IsLocalization.map_eq_zero_iff (.powers (f t))] at hp'
obtain ⟨⟨x, m, (rfl : algebraMap R S t ^ m = x)⟩, e⟩ := hp'
by_cases hp' : 1 ≤ p.natDegree; swap
· obtain rfl : p = 1 := eq_one_of_monic_natDegree_zero hp (by cutsat)
exact ⟨m, by simp [Algebra.smul_def, show algebraMap R S t ^ m = 0 by simpa using e]⟩
refine ⟨m + n, p.scaleRoots (t ^ m), (monic_scaleRoots_iff _).mpr hp, ?_⟩
have := p.scaleRoots_eval₂_mul (algebraMap R S) (t ^ n • r) (t ^ m)
simp only [pow_add, ← Algebra.smul_def, mul_smul, ← map_pow] at e this ⊢
rw [this, ← tsub_add_cancel_of_le hp', pow_succ, mul_smul, e, smul_zero] | theorem | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Localization.Integral"
] | Mathlib/RingTheory/RingHom/Integral.lean | isIntegral_ofLocalizationSpan | `S` is an integral `R`-algebra if there exists a set `{ r }` that
spans `R` such that each `Sᵣ` is an integral `Rᵣ`-algebra. |
Locally {R S : Type u} [CommRing R] [CommRing S] (f : R →+* S) : Prop :=
∃ (s : Set S) (_ : Ideal.span s = ⊤),
∀ t ∈ s, P ((algebraMap S (Localization.Away t)).comp f)
variable {R S : Type u} [CommRing R] [CommRing S] | def | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Away.Lemmas"
] | Mathlib/RingTheory/RingHom/Locally.lean | Locally | For a property of ring homomorphisms `P`, `Locally P` holds for `f : R →+* S` if
it holds locally on `S`, i.e. if there exists a subset `{ t }` of `S` generating
the unit ideal, such that `P` holds for all compositions `R →+* Sₜ`.
We may require `s` to be finite here, for the equivalence, see `locally_iff_finite`. |
locally_iff_finite (f : R →+* S) :
Locally P f ↔ ∃ (s : Finset S) (_ : Ideal.span (s : Set S) = ⊤),
∀ t ∈ s, P ((algebraMap S (Localization.Away t)).comp f) := by
constructor
· intro ⟨s, hsone, hs⟩
obtain ⟨s', h₁, h₂⟩ := (Ideal.span_eq_top_iff_finite s).mp hsone
exact ⟨s', h₂, fun t ht ↦ hs t (h₁ ht)⟩
· intro ⟨s, hsone, hs⟩
use s, hsone, hs
variable {P} | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Away.Lemmas"
] | Mathlib/RingTheory/RingHom/Locally.lean | locally_iff_finite | null |
locally_of_exists (hP : RespectsIso P) (f : R →+* S) {ι : Type*} (s : ι → S)
(hsone : Ideal.span (Set.range s) = ⊤)
(Sₜ : ι → Type u) [∀ i, CommRing (Sₜ i)] [∀ i, Algebra S (Sₜ i)]
[∀ i, IsLocalization.Away (s i) (Sₜ i)] (hf : ∀ i, P ((algebraMap S (Sₜ i)).comp f)) :
Locally P f := by
use Set.range s, hsone
rintro - ⟨i, rfl⟩
let e : Localization.Away (s i) ≃+* Sₜ i :=
(IsLocalization.algEquiv (Submonoid.powers (s i)) _ _).toRingEquiv
have : algebraMap S (Localization.Away (s i)) = e.symm.toRingHom.comp (algebraMap S (Sₜ i)) :=
RingHom.ext (fun x ↦ (AlgEquiv.commutes (IsLocalization.algEquiv _ _ _).symm _).symm)
rw [this, RingHom.comp_assoc]
exact hP.left _ _ (hf i) | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Away.Lemmas"
] | Mathlib/RingTheory/RingHom/Locally.lean | locally_of_exists | If `P` respects isomorphisms, to check `P` holds locally for `f : R →+* S`, it suffices
to check `P` holds on a standard open cover. |
locally_iff_exists (hP : RespectsIso P) (f : R →+* S) :
Locally P f ↔ ∃ (ι : Type u) (s : ι → S) (_ : Ideal.span (Set.range s) = ⊤) (Sₜ : ι → Type u)
(_ : (i : ι) → CommRing (Sₜ i)) (_ : (i : ι) → Algebra S (Sₜ i))
(_ : (i : ι) → IsLocalization.Away (s i : S) (Sₜ i)),
∀ i, P ((algebraMap S (Sₜ i)).comp f) :=
⟨fun ⟨s, hsone, hs⟩ ↦ ⟨s, fun t : s ↦ (t : S), by simpa, fun t ↦ Localization.Away (t : S),
inferInstance, inferInstance, inferInstance, fun t ↦ hs t.val t.property⟩,
fun ⟨ι, s, hsone, Sₜ, _, _, hislocal, hs⟩ ↦ locally_of_exists hP f s hsone Sₜ hs⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Away.Lemmas"
] | Mathlib/RingTheory/RingHom/Locally.lean | locally_iff_exists | Equivalence variant of `locally_of_exists`. This is sometimes easier to use, if the
`IsLocalization.Away` instance can't be automatically inferred. |
locally_iff_isLocalization (hP : RespectsIso P) (f : R →+* S) :
Locally P f ↔ ∃ (s : Finset S) (_ : Ideal.span (s : Set S) = ⊤),
∀ t ∈ s, ∀ (Sₜ : Type u) [CommRing Sₜ] [Algebra S Sₜ] [IsLocalization.Away t Sₜ],
P ((algebraMap S Sₜ).comp f) := by
rw [locally_iff_finite P f]
refine ⟨fun ⟨s, hsone, hs⟩ ↦ ⟨s, hsone, fun t ht Sₜ _ _ _ ↦ ?_⟩, fun ⟨s, hsone, hs⟩ ↦ ?_⟩
· let e : Localization.Away t ≃+* Sₜ :=
(IsLocalization.algEquiv (Submonoid.powers t) _ _).toRingEquiv
have : algebraMap S Sₜ = e.toRingHom.comp (algebraMap S (Localization.Away t)) :=
RingHom.ext (fun x ↦ (AlgEquiv.commutes (IsLocalization.algEquiv _ _ _) _).symm)
rw [this, RingHom.comp_assoc]
exact hP.left _ _ (hs t ht)
· exact ⟨s, hsone, fun t ht ↦ hs t ht _⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Away.Lemmas"
] | Mathlib/RingTheory/RingHom/Locally.lean | locally_iff_isLocalization | In the definition of `Locally` we may replace `Localization.Away` with an arbitrary
algebra satisfying `IsLocalization.Away`. |
locally_of (hP : RespectsIso P) (f : R →+* S) (hf : P f) : Locally P f := by
use {1}
let e : S ≃+* Localization.Away (1 : S) :=
(IsLocalization.atUnits S (Submonoid.powers 1) (by simp)).toRingEquiv
simp only [Set.mem_singleton_iff, forall_eq, Ideal.span_singleton_one, exists_const]
exact hP.left f e hf | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Away.Lemmas"
] | Mathlib/RingTheory/RingHom/Locally.lean | locally_of | If `f` satisfies `P`, then in particular it satisfies `Locally P`. |
locally_of_locally {Q : ∀ {R S : Type u} [CommRing R] [CommRing S], (R →+* S) → Prop}
(hPQ : ∀ {R S : Type u} [CommRing R] [CommRing S] {f : R →+* S}, P f → Q f)
{R S : Type u} [CommRing R] [CommRing S] {f : R →+* S} (hf : Locally P f) : Locally Q f := by
obtain ⟨s, hsone, hs⟩ := hf
exact ⟨s, hsone, fun t ht ↦ hPQ (hs t ht)⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Away.Lemmas"
] | Mathlib/RingTheory/RingHom/Locally.lean | locally_of_locally | null |
locally_iff_of_localizationSpanTarget (hPi : RespectsIso P)
(hPs : OfLocalizationSpanTarget P) {R S : Type u} [CommRing R] [CommRing S] (f : R →+* S) :
Locally P f ↔ P f :=
⟨fun ⟨s, hsone, hs⟩ ↦ hPs f s hsone (fun a ↦ hs a.val a.property), locally_of hPi f⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Away.Lemmas"
] | Mathlib/RingTheory/RingHom/Locally.lean | locally_iff_of_localizationSpanTarget | If `P` is local on the target, then `Locally P` coincides with `P`. |
locally_ofLocalizationSpanTarget (hP : RespectsIso P) :
OfLocalizationSpanTarget (Locally P) := by
intro R S _ _ f s hsone hs
choose t htone ht using hs
rw [locally_iff_exists hP]
refine ⟨(a : s) × t a, IsLocalization.Away.mulNumerator s t,
IsLocalization.Away.span_range_mulNumerator_eq_top hsone htone,
fun ⟨a, b⟩ ↦ Localization.Away b.val, inferInstance, inferInstance, fun ⟨a, b⟩ ↦ ?_, ?_⟩
· haveI : IsLocalization.Away ((algebraMap S (Localization.Away a.val))
(IsLocalization.Away.sec a.val b.val).1) (Localization.Away b.val) := by
apply IsLocalization.Away.of_associated (r := b.val)
rw [← IsLocalization.Away.sec_spec]
apply associated_mul_unit_right
rw [map_pow _ _]
exact IsUnit.pow _ (IsLocalization.Away.algebraMap_isUnit _)
apply IsLocalization.Away.mul' (Localization.Away a.val) (Localization.Away b.val)
· intro ⟨a, b⟩
rw [IsScalarTower.algebraMap_eq S (Localization.Away a.val) (Localization.Away b.val)]
apply ht _ _ b.property | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Away.Lemmas"
] | Mathlib/RingTheory/RingHom/Locally.lean | locally_ofLocalizationSpanTarget | `Locally P` is local on the target. |
locally_respectsIso (hPi : RespectsIso P) : RespectsIso (Locally P) where
left {R S T} _ _ _ f e := fun ⟨s, hsone, hs⟩ ↦ by
refine ⟨e '' s, ?_, ?_⟩
· rw [← Ideal.map_span, hsone, Ideal.map_top]
· rintro - ⟨a, ha, rfl⟩
let e' : Localization.Away a ≃+* Localization.Away (e a) :=
IsLocalization.ringEquivOfRingEquiv _ _ e (Submonoid.map_powers e a)
have : (algebraMap T (Localization.Away (e a))).comp e.toRingHom =
e'.toRingHom.comp (algebraMap S (Localization.Away a)) := by
ext x
simp [e']
rw [← RingHom.comp_assoc, this, RingHom.comp_assoc]
apply hPi.left
exact hs a ha
right {R S T} _ _ _ f e := fun ⟨s, hsone, hs⟩ ↦
⟨s, hsone, fun a ha ↦ (RingHom.comp_assoc _ _ _).symm ▸ hPi.right _ _ (hs a ha)⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Away.Lemmas"
] | Mathlib/RingTheory/RingHom/Locally.lean | locally_respectsIso | If `P` respects isomorphism, so does `Locally P`. |
locally_holdsForLocalizationAway (hPa : HoldsForLocalizationAway P) :
HoldsForLocalizationAway (Locally P) := by
introv R _
use {1}
simp only [Set.mem_singleton_iff, forall_eq, Ideal.span_singleton_one, exists_const]
let e : S ≃ₐ[R] (Localization.Away (1 : S)) :=
(IsLocalization.atUnits S (Submonoid.powers 1) (by simp)).restrictScalars R
haveI : IsLocalization.Away r (Localization.Away (1 : S)) :=
IsLocalization.isLocalization_of_algEquiv (Submonoid.powers r) e
rw [← IsScalarTower.algebraMap_eq]
apply hPa _ r | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Away.Lemmas"
] | Mathlib/RingTheory/RingHom/Locally.lean | locally_holdsForLocalizationAway | If `P` holds for localization away maps, then so does `Locally P`. |
locally_stableUnderComposition (hPi : RespectsIso P) (hPl : LocalizationPreserves P)
(hPc : StableUnderComposition P) :
StableUnderComposition (Locally P) := by
classical
intro R S T _ _ _ f g hf hg
rw [locally_iff_finite] at hf hg
obtain ⟨sf, hsfone, hsf⟩ := hf
obtain ⟨sg, hsgone, hsg⟩ := hg
rw [locally_iff_exists hPi]
refine ⟨sf × sg, fun (a, b) ↦ g a * b, ?_,
fun (a, b) ↦ Localization.Away ((algebraMap T (Localization.Away b.val)) (g a.val)),
inferInstance, inferInstance, inferInstance, ?_⟩
· rw [eq_top_iff, ← hsgone, Ideal.span_le]
intro t ht
have : 1 ∈ Ideal.span (Set.range <| fun a : sf ↦ a.val) := by simp [hsfone]
simp only [Ideal.mem_span_range_iff_exists_fun, SetLike.mem_coe] at this ⊢
obtain ⟨cf, hcf⟩ := this
let cg : sg → T := Pi.single ⟨t, ht⟩ 1
use fun (a, b) ↦ g (cf a) * cg b
simp [cg, Pi.single_apply, Fintype.sum_prod_type, ← mul_assoc, ← Finset.sum_mul, ← map_mul,
← map_sum, hcf] at hcf ⊢
· intro ⟨a, b⟩
let g' := (algebraMap T (Localization.Away b.val)).comp g
let a' := (algebraMap T (Localization.Away b.val)) (g a.val)
have : (algebraMap T <| Localization.Away a').comp (g.comp f) =
(Localization.awayMap g' a.val).comp ((algebraMap S (Localization.Away a.val)).comp f) := by
ext x
simp only [coe_comp, Function.comp_apply, a']
change _ = Localization.awayMap g' a.val (algebraMap S _ (f x))
simp only [Localization.awayMap, IsLocalization.Away.map, IsLocalization.map_eq]
rfl
simp only [this, a']
apply hPc _ _ (hsf a.val a.property)
apply @hPl _ _ _ _ g' _ _ _ _ _ _ _ _ ?_ (hsg b.val b.property)
exact IsLocalization.Away.instMapRingHomPowersOfCoe (Localization.Away (g' a.val)) a.val | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Away.Lemmas"
] | Mathlib/RingTheory/RingHom/Locally.lean | locally_stableUnderComposition | If `P` preserves localizations, then `Locally P` is stable under composition if `P` is. |
locally_StableUnderCompositionWithLocalizationAwayTarget
(hP0 : RespectsIso P)
(hPa : StableUnderCompositionWithLocalizationAwayTarget P) :
StableUnderCompositionWithLocalizationAwayTarget (Locally P) := by
intro R S T _ _ _ _ t _ f hf
simp only [locally_iff_isLocalization hP0 f] at hf
obtain ⟨s, hsone, hs⟩ := hf
refine ⟨algebraMap S T '' s, ?_, ?_⟩
· rw [← Ideal.map_span, hsone, Ideal.map_top]
· rintro - ⟨a, ha, rfl⟩
letI : Algebra (Localization.Away a) (Localization.Away (algebraMap S T a)) :=
(IsLocalization.Away.map _ _ (algebraMap S T) a).toAlgebra
have : (algebraMap (Localization.Away a) (Localization.Away (algebraMap S T a))).comp
(algebraMap S (Localization.Away a)) =
(algebraMap T (Localization.Away (algebraMap S T a))).comp (algebraMap S T) := by
simp [algebraMap_toAlgebra, IsLocalization.Away.map]
rw [← comp_assoc, ← this, comp_assoc]
haveI : IsScalarTower S (Localization.Away a) (Localization.Away ((algebraMap S T) a)) := by
apply IsScalarTower.of_algebraMap_eq
intro x
simp [algebraMap_toAlgebra, IsLocalization.Away.map, ← IsScalarTower.algebraMap_apply]
haveI : IsLocalization.Away (algebraMap S (Localization.Away a) t)
(Localization.Away (algebraMap S T a)) :=
IsLocalization.Away.commutes _ T ((Localization.Away (algebraMap S T a))) a t
apply hPa _ (algebraMap S (Localization.Away a) t)
apply hs a ha | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Away.Lemmas"
] | Mathlib/RingTheory/RingHom/Locally.lean | locally_StableUnderCompositionWithLocalizationAwayTarget | If `P` is stable under composition with localization away maps on the right,
then so is `Locally P`. |
locally_StableUnderCompositionWithLocalizationAwaySource
(hPa : StableUnderCompositionWithLocalizationAwaySource P) :
StableUnderCompositionWithLocalizationAwaySource (Locally P) := by
intro R S T _ _ _ _ r _ f ⟨s, hsone, hs⟩
refine ⟨s, hsone, fun t ht ↦ ?_⟩
rw [← comp_assoc]
exact hPa _ r _ (hs t ht)
attribute [local instance] Algebra.TensorProduct.rightAlgebra in | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Away.Lemmas"
] | Mathlib/RingTheory/RingHom/Locally.lean | locally_StableUnderCompositionWithLocalizationAwaySource | If `P` is stable under composition with localization away maps on the left,
then so is `Locally P`. |
locally_isStableUnderBaseChange (hPi : RespectsIso P) (hPb : IsStableUnderBaseChange P) :
IsStableUnderBaseChange (Locally P) := by
apply IsStableUnderBaseChange.mk (locally_respectsIso hPi)
introv hf
obtain ⟨s, hsone, hs⟩ := hf
rw [locally_iff_exists hPi]
letI (a : s) : Algebra (S ⊗[R] T) (S ⊗[R] Localization.Away a.val) :=
(Algebra.TensorProduct.map (AlgHom.id R S) (IsScalarTower.toAlgHom R _ _)).toRingHom.toAlgebra
letI (a : s) : Algebra T (S ⊗[R] Localization.Away a.val) :=
((algebraMap _ (S ⊗[R] Localization.Away a.val)).comp (algebraMap T (S ⊗[R] T))).toAlgebra
haveI (a : s) : IsScalarTower T (S ⊗[R] T) (S ⊗[R] Localization.Away a.val) :=
IsScalarTower.of_algebraMap_eq' rfl
haveI (a : s) : IsScalarTower T (Localization.Away a.val) (S ⊗[R] Localization.Away a.val) :=
IsScalarTower.of_algebraMap_eq' rfl
haveI (a : s) : IsScalarTower S (S ⊗[R] T) (S ⊗[R] Localization.Away a.val) :=
IsScalarTower.of_algebraMap_eq <| by
intro x
simp [RingHom.algebraMap_toAlgebra]
haveI (a : s) : Algebra.IsPushout T (Localization.Away a.val) (S ⊗[R] T)
(S ⊗[R] Localization.Away a.val) := by
rw [← Algebra.IsPushout.comp_iff R _ S]
infer_instance
refine ⟨s, fun a ↦ Algebra.TensorProduct.includeRight a.val, ?_,
fun a ↦ (S ⊗[R] Localization.Away a.val), inferInstance, inferInstance, ?_, ?_⟩
· rw [← Set.image_eq_range, ← Ideal.map_span, hsone, Ideal.map_top]
· intro a
convert_to IsLocalization (Algebra.algebraMapSubmonoid (S ⊗[R] T) (Submonoid.powers a.val))
(S ⊗[R] Localization.Away a.val)
· simp only [Algebra.TensorProduct.includeRight_apply, Algebra.algebraMapSubmonoid,
Submonoid.map_powers]
rfl
· rw [← isLocalizedModule_iff_isLocalization, isLocalizedModule_iff_isBaseChange
(S := Submonoid.powers a.val) (A := Localization.Away a.val)]
exact Algebra.IsPushout.out
· intro a
rw [← IsScalarTower.algebraMap_eq]
apply hPb R (Localization.Away a.val)
rw [IsScalarTower.algebraMap_eq R T]
exact hs a a.property | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Away.Lemmas"
] | Mathlib/RingTheory/RingHom/Locally.lean | locally_isStableUnderBaseChange | If `P` is stable under base change, then so is `Locally P`. |
locally_localizationAwayPreserves (hPl : LocalizationAwayPreserves P) :
LocalizationAwayPreserves (Locally P) := by
introv R hf
obtain ⟨s, hsone, hs⟩ := hf
rw [locally_iff_exists hPl.respectsIso]
let rₐ (a : s) : Localization.Away a.val := algebraMap _ _ (f r)
let Sₐ (a : s) := Localization.Away (rₐ a)
haveI (a : s) :
IsLocalization.Away (((algebraMap S (Localization.Away a.val)).comp f) r) (Sₐ a) :=
inferInstanceAs (IsLocalization.Away (rₐ a) (Sₐ a))
haveI (a : s) : IsLocalization (Algebra.algebraMapSubmonoid (Localization.Away a.val)
(Submonoid.map f (Submonoid.powers r))) (Sₐ a) := by
convert inferInstanceAs (IsLocalization.Away (rₐ a) (Sₐ a))
simp [rₐ, Algebra.algebraMapSubmonoid]
have H (a : s) : Submonoid.powers (f r) ≤
(Submonoid.powers (rₐ a)).comap (algebraMap S (Localization.Away a.val)) := by
simp [rₐ, Submonoid.powers_le]
letI (a : s) : Algebra S' (Sₐ a) :=
(IsLocalization.map (Sₐ a) (algebraMap S (Localization.Away a.val)) (H a)).toAlgebra
haveI (a : s) : IsScalarTower S S' (Sₐ a) :=
IsScalarTower.of_algebraMap_eq' (IsLocalization.map_comp (H a)).symm
refine ⟨s, fun a ↦ algebraMap S S' a.val, ?_, Sₐ,
inferInstance, inferInstance, fun a ↦ ?_, fun a ↦ ?_⟩
· rw [← Set.image_eq_range, ← Ideal.map_span, hsone, Ideal.map_top]
· convert IsLocalization.commutes (T := Sₐ a) (M₁ := (Submonoid.powers r).map f) (S₁ := S')
(S₂ := Localization.Away a.val) (M₂ := Submonoid.powers a.val)
simp [Algebra.algebraMapSubmonoid]
· rw [algebraMap_toAlgebra, IsLocalization.Away.map, IsLocalization.map_comp_map]
exact hPl ((algebraMap _ (Localization.Away a.val)).comp f) r R' (Sₐ a) (hs _ a.2) | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Away.Lemmas"
] | Mathlib/RingTheory/RingHom/Locally.lean | locally_localizationAwayPreserves | If `P` is preserved by localization away, then so is `Locally P`. |
locally_localizationPreserves (hPl : LocalizationPreserves P) :
LocalizationPreserves (Locally P) := by
introv R hf
obtain ⟨s, hsone, hs⟩ := hf
rw [locally_iff_exists hPl.away.respectsIso]
let Mₐ (a : s) : Submonoid (Localization.Away a.val) :=
(M.map f).map (algebraMap S (Localization.Away a.val))
let Sₐ (a : s) := Localization (Mₐ a)
have hM (a : s) : M.map ((algebraMap S (Localization.Away a.val)).comp f) = Mₐ a :=
(M.map_map _ _).symm
haveI (a : s) :
IsLocalization (M.map ((algebraMap S (Localization.Away a.val)).comp f)) (Sₐ a) := by
rw [hM]
infer_instance
haveI (a : s) :
IsLocalization (Algebra.algebraMapSubmonoid (Localization.Away a.val) (M.map f)) (Sₐ a) :=
inferInstanceAs <| IsLocalization (Mₐ a) (Sₐ a)
letI (a : s) : Algebra S' (Sₐ a) :=
(IsLocalization.map (Sₐ a) (algebraMap S (Localization.Away a.val))
(M.map f).le_comap_map).toAlgebra
haveI (a : s) : IsScalarTower S S' (Sₐ a) :=
IsScalarTower.of_algebraMap_eq' (IsLocalization.map_comp (M.map f).le_comap_map).symm
refine ⟨s, fun a ↦ algebraMap S S' a.val, ?_, Sₐ,
inferInstance, inferInstance, fun a ↦ ?_, fun a ↦ ?_⟩
· rw [← Set.image_eq_range, ← Ideal.map_span, hsone, Ideal.map_top]
· convert IsLocalization.commutes (T := Sₐ a) (M₁ := M.map f) (S₁ := S')
(S₂ := Localization.Away a.val) (M₂ := Submonoid.powers a.val)
simp [Algebra.algebraMapSubmonoid]
· rw [algebraMap_toAlgebra, IsLocalization.map_comp_map]
apply hPl
exact hs a.val a.property | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Away.Lemmas"
] | Mathlib/RingTheory/RingHom/Locally.lean | locally_localizationPreserves | If `P` is preserved by localizations, then so is `Locally P`. |
locally_propertyIsLocal (hPl : LocalizationAwayPreserves P)
(hPa : StableUnderCompositionWithLocalizationAway P) : PropertyIsLocal (Locally P) where
localizationAwayPreserves := locally_localizationAwayPreserves hPl
StableUnderCompositionWithLocalizationAwayTarget :=
locally_StableUnderCompositionWithLocalizationAwayTarget hPl.respectsIso hPa.right
ofLocalizationSpan := (locally_ofLocalizationSpanTarget hPl.respectsIso).ofLocalizationSpan
(locally_StableUnderCompositionWithLocalizationAwaySource hPa.left)
ofLocalizationSpanTarget := locally_ofLocalizationSpanTarget hPl.respectsIso | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Away.Lemmas"
] | Mathlib/RingTheory/RingHom/Locally.lean | locally_propertyIsLocal | If `P` is preserved by localizations and stable under composition with localization
away maps, then `Locally P` is a local property of ring homomorphisms. |
@[mk_iff] IsStandardOpenImmersion (R S : Type*) [CommSemiring R] [CommSemiring S]
[Algebra R S] : Prop where
exists_away (R S) : ∃ r : R, IsLocalization.Away r S
open IsStandardOpenImmersion | class | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/OpenImmersion.lean | IsStandardOpenImmersion | A standard open immersion is one that is a localization map away from some element. |
@[trans] IsStandardOpenImmersion.trans [Algebra S T] [IsScalarTower R S T]
[IsStandardOpenImmersion R S] [IsStandardOpenImmersion S T] :
IsStandardOpenImmersion R T :=
let ⟨r, _⟩ := exists_away R S
let ⟨s, _⟩ := exists_away S T
have : Away (algebraMap R S (sec r s).1) T :=
.of_associated (associated_sec_fst r s).symm
⟨r * (sec r s).1, mul' S T r _⟩
open _root_.TensorProduct in | theorem | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/OpenImmersion.lean | IsStandardOpenImmersion.trans | null |
@[algebraize RingHom.IsStandardOpenImmersion.toAlgebra]
IsStandardOpenImmersion : Prop :=
letI := f.toAlgebra
Algebra.IsStandardOpenImmersion R S | def | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/OpenImmersion.lean | IsStandardOpenImmersion | A standard open immersion is one that is a localization map away from some element. |
isStandardOpenImmersion_algebraMap [Algebra R S] :
(algebraMap R S).IsStandardOpenImmersion ↔ Algebra.IsStandardOpenImmersion R S := by
rw [IsStandardOpenImmersion, toAlgebra_algebraMap] | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/OpenImmersion.lean | isStandardOpenImmersion_algebraMap | null |
protected algebraMap [Algebra R S] (r : R) [IsLocalization.Away r S] :
(algebraMap R S).IsStandardOpenImmersion :=
isStandardOpenImmersion_algebraMap.2 ⟨r, inferInstance⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/OpenImmersion.lean | algebraMap | null |
toAlgebra {f : R →+* S} (hf : f.IsStandardOpenImmersion) :
@Algebra.IsStandardOpenImmersion R S _ _ f.toAlgebra :=
letI := f.toAlgebra; hf | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/OpenImmersion.lean | toAlgebra | null |
of_bijective {f : R →+* S} (hf : Function.Bijective f) : f.IsStandardOpenImmersion :=
letI := f.toAlgebra
⟨1, IsLocalization.away_of_isUnit_of_bijective _ isUnit_one hf⟩
variable (R) in | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/OpenImmersion.lean | of_bijective | A bijective ring map is a standard open immersion. |
id : (RingHom.id R).IsStandardOpenImmersion :=
of_bijective Function.bijective_id
variable {f g} in | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/OpenImmersion.lean | id | The identity map of a ring is a standard open immersion. |
comp (hf : f.IsStandardOpenImmersion) (hg : g.IsStandardOpenImmersion) :
(g.comp f).IsStandardOpenImmersion := by
algebraize [f, g, g.comp f]
obtain ⟨r, hr⟩ := hf
obtain ⟨s, hs⟩ := hg
exact .trans _ S _ | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/OpenImmersion.lean | comp | The composition of two standard open immersions is a standard open immersion. |
containsIdentities : ContainsIdentities.{u} IsStandardOpenImmersion := id | theorem | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/OpenImmersion.lean | containsIdentities | null |
stableUnderComposition : StableUnderComposition.{u} IsStandardOpenImmersion := @comp | theorem | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/OpenImmersion.lean | stableUnderComposition | null |
respectsIso : RespectsIso.{u} IsStandardOpenImmersion :=
stableUnderComposition.respectsIso fun e ↦ of_bijective e.bijective | theorem | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/OpenImmersion.lean | respectsIso | null |
isStableUnderBaseChange : IsStableUnderBaseChange.{u} IsStandardOpenImmersion := by
refine .mk respectsIso ?_
introv h
rw [isStandardOpenImmersion_algebraMap] at h ⊢
infer_instance | theorem | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/OpenImmersion.lean | isStableUnderBaseChange | null |
holdsForLocalizationAway : HoldsForLocalizationAway.{u} IsStandardOpenImmersion := by
introv R h
exact .algebraMap r | theorem | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/OpenImmersion.lean | holdsForLocalizationAway | null |
@[algebraize RingHom.FormallySmooth.toAlgebra]
FormallySmooth (f : R →+* S) : Prop :=
letI := f.toAlgebra
Algebra.FormallySmooth R S | def | RingTheory | [
"Mathlib.RingTheory.RingHom.FinitePresentation",
"Mathlib.RingTheory.Smooth.Locus"
] | Mathlib/RingTheory/RingHom/Smooth.lean | FormallySmooth | A ring homomorphism `f : R →+* S` is formally smooth
if `S` is formally smooth as an `R` algebra. |
FormallySmooth.toAlgebra {f : R →+* S} (hf : FormallySmooth f) :
@Algebra.FormallySmooth R _ S _ f.toAlgebra := hf | lemma | RingTheory | [
"Mathlib.RingTheory.RingHom.FinitePresentation",
"Mathlib.RingTheory.Smooth.Locus"
] | Mathlib/RingTheory/RingHom/Smooth.lean | FormallySmooth.toAlgebra | Helper lemma for the `algebraize` tactic |
formallySmooth_algebraMap [Algebra R S] :
(algebraMap R S).FormallySmooth ↔ Algebra.FormallySmooth R S := by
rw [FormallySmooth, toAlgebra_algebraMap] | lemma | RingTheory | [
"Mathlib.RingTheory.RingHom.FinitePresentation",
"Mathlib.RingTheory.Smooth.Locus"
] | Mathlib/RingTheory/RingHom/Smooth.lean | formallySmooth_algebraMap | null |
FormallySmooth.holdsForLocalizationAway : HoldsForLocalizationAway @FormallySmooth :=
fun _ _ _ _ _ r _ ↦ formallySmooth_algebraMap.mpr <| .of_isLocalization (.powers r) | lemma | RingTheory | [
"Mathlib.RingTheory.RingHom.FinitePresentation",
"Mathlib.RingTheory.Smooth.Locus"
] | Mathlib/RingTheory/RingHom/Smooth.lean | FormallySmooth.holdsForLocalizationAway | null |
FormallySmooth.stableUnderComposition : StableUnderComposition @FormallySmooth := by
intro R S T _ _ _ f g hf hg
algebraize [f, g, g.comp f]
exact .comp R S T | lemma | RingTheory | [
"Mathlib.RingTheory.RingHom.FinitePresentation",
"Mathlib.RingTheory.Smooth.Locus"
] | Mathlib/RingTheory/RingHom/Smooth.lean | FormallySmooth.stableUnderComposition | null |
FormallySmooth.respectsIso : RespectsIso @FormallySmooth :=
stableUnderComposition.respectsIso fun e ↦ holdsForLocalizationAway.of_bijective _ _ e.bijective | lemma | RingTheory | [
"Mathlib.RingTheory.RingHom.FinitePresentation",
"Mathlib.RingTheory.Smooth.Locus"
] | Mathlib/RingTheory/RingHom/Smooth.lean | FormallySmooth.respectsIso | null |
FormallySmooth.isStableUnderBaseChange : IsStableUnderBaseChange @FormallySmooth := by
refine .mk respectsIso ?_
introv H
rw [formallySmooth_algebraMap] at H ⊢
infer_instance | lemma | RingTheory | [
"Mathlib.RingTheory.RingHom.FinitePresentation",
"Mathlib.RingTheory.Smooth.Locus"
] | Mathlib/RingTheory/RingHom/Smooth.lean | FormallySmooth.isStableUnderBaseChange | null |
FormallySmooth.localizationPreserves : LocalizationPreserves @FormallySmooth :=
isStableUnderBaseChange.localizationPreserves | lemma | RingTheory | [
"Mathlib.RingTheory.RingHom.FinitePresentation",
"Mathlib.RingTheory.Smooth.Locus"
] | Mathlib/RingTheory/RingHom/Smooth.lean | FormallySmooth.localizationPreserves | null |
@[algebraize RingHom.Smooth.toAlgebra]
Smooth (f : R →+* S) : Prop :=
letI : Algebra R S := f.toAlgebra
Algebra.Smooth R S | def | RingTheory | [
"Mathlib.RingTheory.RingHom.FinitePresentation",
"Mathlib.RingTheory.Smooth.Locus"
] | Mathlib/RingTheory/RingHom/Smooth.lean | Smooth | A ring homomorphism `f : R →+* S` is smooth if `S` is smooth as an `R` algebra. |
Smooth.toAlgebra {f : R →+* S} (hf : Smooth f) :
@Algebra.Smooth R _ S _ f.toAlgebra := hf | lemma | RingTheory | [
"Mathlib.RingTheory.RingHom.FinitePresentation",
"Mathlib.RingTheory.Smooth.Locus"
] | Mathlib/RingTheory/RingHom/Smooth.lean | Smooth.toAlgebra | Helper lemma for the `algebraize` tactic |
smooth_algebraMap [Algebra R S] :
(algebraMap R S).Smooth ↔ Algebra.Smooth R S := by
rw [RingHom.Smooth, toAlgebra_algebraMap] | lemma | RingTheory | [
"Mathlib.RingTheory.RingHom.FinitePresentation",
"Mathlib.RingTheory.Smooth.Locus"
] | Mathlib/RingTheory/RingHom/Smooth.lean | smooth_algebraMap | null |
smooth_def {f : R →+* S} : f.Smooth ↔ f.FormallySmooth ∧ f.FinitePresentation :=
letI := f.toAlgebra
Algebra.smooth_iff _ _ | lemma | RingTheory | [
"Mathlib.RingTheory.RingHom.FinitePresentation",
"Mathlib.RingTheory.Smooth.Locus"
] | Mathlib/RingTheory/RingHom/Smooth.lean | smooth_def | null |
stableUnderComposition : StableUnderComposition Smooth := by
convert RingHom.FormallySmooth.stableUnderComposition.and
RingHom.finitePresentation_stableUnderComposition
rw [smooth_def] | lemma | RingTheory | [
"Mathlib.RingTheory.RingHom.FinitePresentation",
"Mathlib.RingTheory.Smooth.Locus"
] | Mathlib/RingTheory/RingHom/Smooth.lean | stableUnderComposition | null |
isStableUnderBaseChange : IsStableUnderBaseChange Smooth := by
convert RingHom.FormallySmooth.isStableUnderBaseChange.and
RingHom.finitePresentation_isStableUnderBaseChange
rw [smooth_def] | lemma | RingTheory | [
"Mathlib.RingTheory.RingHom.FinitePresentation",
"Mathlib.RingTheory.Smooth.Locus"
] | Mathlib/RingTheory/RingHom/Smooth.lean | isStableUnderBaseChange | null |
holdsForLocalizationAway : HoldsForLocalizationAway Smooth := by
introv R h
rw [smooth_algebraMap]
exact ⟨Algebra.FormallySmooth.of_isLocalization (.powers r),
IsLocalization.Away.finitePresentation r⟩
variable (R) in | lemma | RingTheory | [
"Mathlib.RingTheory.RingHom.FinitePresentation",
"Mathlib.RingTheory.Smooth.Locus"
] | Mathlib/RingTheory/RingHom/Smooth.lean | holdsForLocalizationAway | null |
id : RingHom.Smooth (RingHom.id R) :=
holdsForLocalizationAway.containsIdentities R | lemma | RingTheory | [
"Mathlib.RingTheory.RingHom.FinitePresentation",
"Mathlib.RingTheory.Smooth.Locus"
] | Mathlib/RingTheory/RingHom/Smooth.lean | id | The identity of a ring is smooth. |
comp {f : R →+* S} {g : S →+* T} (hf : f.Smooth) (hg : g.Smooth) : (g.comp f).Smooth :=
stableUnderComposition f g hf hg | lemma | RingTheory | [
"Mathlib.RingTheory.RingHom.FinitePresentation",
"Mathlib.RingTheory.Smooth.Locus"
] | Mathlib/RingTheory/RingHom/Smooth.lean | comp | Composition of smooth ring homomorphisms is smooth. |
ofLocalizationSpanTarget : OfLocalizationSpanTarget Smooth := by
introv R hs hf
have : f.FinitePresentation :=
finitePresentation_ofLocalizationSpanTarget _ s hs fun r ↦ (hf r).finitePresentation
algebraize [f]
refine ⟨?_, ‹_›⟩
rw [← Algebra.smoothLocus_eq_univ_iff, ← Set.univ_subset_iff, ← TopologicalSpace.Opens.coe_top,
← PrimeSpectrum.iSup_basicOpen_eq_top_iff'.mpr hs]
simp only [TopologicalSpace.Opens.coe_iSup, Set.iUnion_subset_iff,
Algebra.basicOpen_subset_smoothLocus_iff, ← formallySmooth_algebraMap]
exact fun r hr ↦ (hf ⟨r, hr⟩).1 | lemma | RingTheory | [
"Mathlib.RingTheory.RingHom.FinitePresentation",
"Mathlib.RingTheory.Smooth.Locus"
] | Mathlib/RingTheory/RingHom/Smooth.lean | ofLocalizationSpanTarget | null |
propertyIsLocal : PropertyIsLocal Smooth where
localizationAwayPreserves := isStableUnderBaseChange.localizationPreserves.away
ofLocalizationSpanTarget := ofLocalizationSpanTarget
ofLocalizationSpan := ofLocalizationSpanTarget.ofLocalizationSpan
(stableUnderComposition.stableUnderCompositionWithLocalizationAway
holdsForLocalizationAway).left
StableUnderCompositionWithLocalizationAwayTarget :=
(stableUnderComposition.stableUnderCompositionWithLocalizationAway
holdsForLocalizationAway).right | lemma | RingTheory | [
"Mathlib.RingTheory.RingHom.FinitePresentation",
"Mathlib.RingTheory.Smooth.Locus"
] | Mathlib/RingTheory/RingHom/Smooth.lean | propertyIsLocal | Smoothness is a local property of ring homomorphisms. |
@[algebraize RingHom.IsStandardSmooth.toAlgebra]
IsStandardSmooth (f : R →+* S) : Prop :=
@Algebra.IsStandardSmooth _ _ _ _ f.toAlgebra | def | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.Tactic.Algebraize"
] | Mathlib/RingTheory/RingHom/StandardSmooth.lean | IsStandardSmooth | A ring homomorphism `R →+* S` is standard smooth if `S` is standard smooth as `R`-algebra. |
IsStandardSmooth.toAlgebra {f : R →+* S} (hf : IsStandardSmooth f) :
@Algebra.IsStandardSmooth R S _ _ f.toAlgebra := hf | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.Tactic.Algebraize"
] | Mathlib/RingTheory/RingHom/StandardSmooth.lean | IsStandardSmooth.toAlgebra | Helper lemma for the `algebraize` tactic |
@[algebraize RingHom.IsStandardSmoothOfRelativeDimension.toAlgebra]
IsStandardSmoothOfRelativeDimension (f : R →+* S) : Prop :=
@Algebra.IsStandardSmoothOfRelativeDimension n _ _ _ _ f.toAlgebra | def | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.Tactic.Algebraize"
] | Mathlib/RingTheory/RingHom/StandardSmooth.lean | IsStandardSmoothOfRelativeDimension | A ring homomorphism `R →+* S` is standard smooth of relative dimension `n` if
`S` is standard smooth of relative dimension `n` as `R`-algebra. |
IsStandardSmoothOfRelativeDimension.toAlgebra {f : R →+* S}
(hf : IsStandardSmoothOfRelativeDimension n f) :
@Algebra.IsStandardSmoothOfRelativeDimension n R S _ _ f.toAlgebra := hf | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.Tactic.Algebraize"
] | Mathlib/RingTheory/RingHom/StandardSmooth.lean | IsStandardSmoothOfRelativeDimension.toAlgebra | Helper lemma for the `algebraize` tactic |
IsStandardSmoothOfRelativeDimension.isStandardSmooth (f : R →+* S)
(hf : IsStandardSmoothOfRelativeDimension n f) :
IsStandardSmooth f := by
algebraize [f]
exact Algebra.IsStandardSmoothOfRelativeDimension.isStandardSmooth n
variable {n m}
variable (R) in | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.Tactic.Algebraize"
] | Mathlib/RingTheory/RingHom/StandardSmooth.lean | IsStandardSmoothOfRelativeDimension.isStandardSmooth | null |
IsStandardSmoothOfRelativeDimension.id :
IsStandardSmoothOfRelativeDimension 0 (RingHom.id R) :=
Algebra.IsStandardSmoothOfRelativeDimension.id R | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.Tactic.Algebraize"
] | Mathlib/RingTheory/RingHom/StandardSmooth.lean | IsStandardSmoothOfRelativeDimension.id | null |
IsStandardSmoothOfRelativeDimension.equiv (e : R ≃+* S) :
IsStandardSmoothOfRelativeDimension 0 (e : R →+* S) := by
algebraize [e.toRingHom]
exact Algebra.IsStandardSmoothOfRelativeDimension.of_algebraMap_bijective e.bijective
variable {T : Type*} [CommRing T] | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.Tactic.Algebraize"
] | Mathlib/RingTheory/RingHom/StandardSmooth.lean | IsStandardSmoothOfRelativeDimension.equiv | null |
IsStandardSmooth.comp {g : S →+* T} {f : R →+* S}
(hg : IsStandardSmooth g) (hf : IsStandardSmooth f) :
IsStandardSmooth (g.comp f) := by
rw [IsStandardSmooth]
algebraize [f, g, (g.comp f)]
exact Algebra.IsStandardSmooth.trans R S T | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.Tactic.Algebraize"
] | Mathlib/RingTheory/RingHom/StandardSmooth.lean | IsStandardSmooth.comp | null |
IsStandardSmoothOfRelativeDimension.comp {g : S →+* T} {f : R →+* S}
(hg : IsStandardSmoothOfRelativeDimension n g)
(hf : IsStandardSmoothOfRelativeDimension m f) :
IsStandardSmoothOfRelativeDimension (n + m) (g.comp f) := by
rw [IsStandardSmoothOfRelativeDimension]
algebraize [f, g, (g.comp f)]
exact Algebra.IsStandardSmoothOfRelativeDimension.trans m n R S T | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.Tactic.Algebraize"
] | Mathlib/RingTheory/RingHom/StandardSmooth.lean | IsStandardSmoothOfRelativeDimension.comp | null |
isStandardSmooth_stableUnderComposition :
StableUnderComposition @IsStandardSmooth :=
fun _ _ _ _ _ _ _ _ hf hg ↦ hg.comp hf | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.Tactic.Algebraize"
] | Mathlib/RingTheory/RingHom/StandardSmooth.lean | isStandardSmooth_stableUnderComposition | null |
isStandardSmooth_respectsIso : RespectsIso @IsStandardSmooth := by
apply isStandardSmooth_stableUnderComposition.respectsIso
introv
exact (IsStandardSmoothOfRelativeDimension.equiv e).isStandardSmooth | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.Tactic.Algebraize"
] | Mathlib/RingTheory/RingHom/StandardSmooth.lean | isStandardSmooth_respectsIso | null |
isStandardSmoothOfRelativeDimension_respectsIso :
RespectsIso (@IsStandardSmoothOfRelativeDimension n) where
left {R S T _ _ _} f e hf := by
rw [← zero_add n]
exact (IsStandardSmoothOfRelativeDimension.equiv e).comp hf
right {R S T _ _ _} f e hf := by
rw [← add_zero n]
exact hf.comp (IsStandardSmoothOfRelativeDimension.equiv e) | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.Tactic.Algebraize"
] | Mathlib/RingTheory/RingHom/StandardSmooth.lean | isStandardSmoothOfRelativeDimension_respectsIso | null |
isStandardSmooth_isStableUnderBaseChange :
IsStableUnderBaseChange @IsStandardSmooth := by
apply IsStableUnderBaseChange.mk
· exact isStandardSmooth_respectsIso
· introv h
replace h : Algebra.IsStandardSmooth R T := by
rw [RingHom.IsStandardSmooth] at h; convert h; ext; simp_rw [Algebra.smul_def]; rfl
suffices Algebra.IsStandardSmooth S (S ⊗[R] T) by
rw [RingHom.IsStandardSmooth]; convert this; ext; simp_rw [Algebra.smul_def]; rfl
infer_instance
variable (n) | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.Tactic.Algebraize"
] | Mathlib/RingTheory/RingHom/StandardSmooth.lean | isStandardSmooth_isStableUnderBaseChange | null |
isStandardSmoothOfRelativeDimension_isStableUnderBaseChange :
IsStableUnderBaseChange (@IsStandardSmoothOfRelativeDimension n) := by
apply IsStableUnderBaseChange.mk
· exact isStandardSmoothOfRelativeDimension_respectsIso
· introv h
replace h : Algebra.IsStandardSmoothOfRelativeDimension n R T := by
rw [RingHom.IsStandardSmoothOfRelativeDimension] at h
convert h; ext; simp_rw [Algebra.smul_def]; rfl
suffices Algebra.IsStandardSmoothOfRelativeDimension n S (S ⊗[R] T) by
rw [RingHom.IsStandardSmoothOfRelativeDimension]
convert this; ext; simp_rw [Algebra.smul_def]; rfl
infer_instance | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.Tactic.Algebraize"
] | Mathlib/RingTheory/RingHom/StandardSmooth.lean | isStandardSmoothOfRelativeDimension_isStableUnderBaseChange | null |
IsStandardSmoothOfRelativeDimension.algebraMap_isLocalizationAway {Rᵣ : Type*} [CommRing Rᵣ]
[Algebra R Rᵣ] (r : R) [IsLocalization.Away r Rᵣ] :
IsStandardSmoothOfRelativeDimension 0 (algebraMap R Rᵣ) := by
have : (algebraMap R Rᵣ).toAlgebra = ‹Algebra R Rᵣ› := by
ext
rw [Algebra.smul_def]
rfl
rw [IsStandardSmoothOfRelativeDimension, this]
exact Algebra.IsStandardSmoothOfRelativeDimension.localization_away r | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.Tactic.Algebraize"
] | Mathlib/RingTheory/RingHom/StandardSmooth.lean | IsStandardSmoothOfRelativeDimension.algebraMap_isLocalizationAway | null |
isStandardSmooth_localizationPreserves : LocalizationPreserves IsStandardSmooth :=
isStandardSmooth_isStableUnderBaseChange.localizationPreserves | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.Tactic.Algebraize"
] | Mathlib/RingTheory/RingHom/StandardSmooth.lean | isStandardSmooth_localizationPreserves | null |
isStandardSmoothOfRelativeDimension_localizationPreserves :
LocalizationPreserves (IsStandardSmoothOfRelativeDimension n) :=
(isStandardSmoothOfRelativeDimension_isStableUnderBaseChange n).localizationPreserves | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.Tactic.Algebraize"
] | Mathlib/RingTheory/RingHom/StandardSmooth.lean | isStandardSmoothOfRelativeDimension_localizationPreserves | null |
isStandardSmooth_holdsForLocalizationAway :
HoldsForLocalizationAway IsStandardSmooth := by
introv R h
exact (IsStandardSmoothOfRelativeDimension.algebraMap_isLocalizationAway r).isStandardSmooth | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.Tactic.Algebraize"
] | Mathlib/RingTheory/RingHom/StandardSmooth.lean | isStandardSmooth_holdsForLocalizationAway | null |
isStandardSmoothOfRelativeDimension_holdsForLocalizationAway :
HoldsForLocalizationAway (IsStandardSmoothOfRelativeDimension 0) := by
introv R h
exact IsStandardSmoothOfRelativeDimension.algebraMap_isLocalizationAway r | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.Tactic.Algebraize"
] | Mathlib/RingTheory/RingHom/StandardSmooth.lean | isStandardSmoothOfRelativeDimension_holdsForLocalizationAway | null |
isStandardSmooth_stableUnderCompositionWithLocalizationAway :
StableUnderCompositionWithLocalizationAway IsStandardSmooth :=
isStandardSmooth_stableUnderComposition.stableUnderCompositionWithLocalizationAway
isStandardSmooth_holdsForLocalizationAway | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.Tactic.Algebraize"
] | Mathlib/RingTheory/RingHom/StandardSmooth.lean | isStandardSmooth_stableUnderCompositionWithLocalizationAway | null |
isStandardSmoothOfRelativeDimension_stableUnderCompositionWithLocalizationAway :
StableUnderCompositionWithLocalizationAway (IsStandardSmoothOfRelativeDimension n) where
left R S _ _ _ _ _ r _ _ hf :=
have : (algebraMap R S).IsStandardSmoothOfRelativeDimension 0 :=
IsStandardSmoothOfRelativeDimension.algebraMap_isLocalizationAway r
add_zero n ▸ IsStandardSmoothOfRelativeDimension.comp hf this
right _ S T _ _ _ _ s _ _ hf :=
have : (algebraMap S T).IsStandardSmoothOfRelativeDimension 0 :=
IsStandardSmoothOfRelativeDimension.algebraMap_isLocalizationAway s
zero_add n ▸ IsStandardSmoothOfRelativeDimension.comp this hf | lemma | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.Tactic.Algebraize"
] | Mathlib/RingTheory/RingHom/StandardSmooth.lean | isStandardSmoothOfRelativeDimension_stableUnderCompositionWithLocalizationAway | null |
surjective_stableUnderComposition : StableUnderComposition surjective := by
introv R hf hg; exact hg.comp hf | theorem | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/Surjective.lean | surjective_stableUnderComposition | null |
surjective_respectsIso : RespectsIso surjective := by
apply surjective_stableUnderComposition.respectsIso
intro _ _ _ _ e
exact e.surjective | theorem | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/Surjective.lean | surjective_respectsIso | null |
surjective_isStableUnderBaseChange : IsStableUnderBaseChange surjective := by
refine IsStableUnderBaseChange.mk surjective_respectsIso ?_
classical
introv h x
induction x with
| zero => exact ⟨0, map_zero _⟩
| tmul x y =>
obtain ⟨y, rfl⟩ := h y; use y • x; dsimp
rw [TensorProduct.smul_tmul, Algebra.algebraMap_eq_smul_one]
| add x y ex ey => obtain ⟨⟨x, rfl⟩, ⟨y, rfl⟩⟩ := ex, ey; exact ⟨x + y, map_add _ x y⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/Surjective.lean | surjective_isStableUnderBaseChange | null |
surjective_localizationPreserves :
LocalizationPreserves surjective := by
introv R H x
obtain ⟨x, ⟨_, s, hs, rfl⟩, rfl⟩ := IsLocalization.mk'_surjective (M.map f) x
obtain ⟨y, rfl⟩ := H x
use IsLocalization.mk' R' y ⟨s, hs⟩
rw [IsLocalization.map_mk'] | theorem | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/Surjective.lean | surjective_localizationPreserves | `M⁻¹R →+* M⁻¹S` is surjective if `R →+* S` is surjective. |
surjective_ofLocalizationSpan : OfLocalizationSpan surjective := by
introv R e H
rw [← Set.range_eq_univ, Set.eq_univ_iff_forall]
letI := f.toAlgebra
intro x
apply Submodule.mem_of_span_eq_top_of_smul_pow_mem
(LinearMap.range (Algebra.linearMap R S)) s e
intro r
obtain ⟨a, e'⟩ := H r (algebraMap _ _ x)
obtain ⟨b, ⟨_, n, rfl⟩, rfl⟩ := IsLocalization.mk'_surjective (Submonoid.powers (r : R)) a
rw [Localization.awayMap, IsLocalization.Away.map, IsLocalization.map_mk', eq_comm,
IsLocalization.eq_mk'_iff_mul_eq, Subtype.coe_mk, Subtype.coe_mk, ← map_mul] at e'
obtain ⟨⟨_, n', rfl⟩, e''⟩ := (IsLocalization.eq_iff_exists (Submonoid.powers (f r)) _).mp e'
dsimp only at e''
rw [mul_comm x, ← mul_assoc, ← map_pow, ← map_mul, ← map_mul, ← pow_add] at e''
exact ⟨n' + n, _, e''.symm⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/Surjective.lean | surjective_ofLocalizationSpan | `R →+* S` is surjective if there exists a set `{ r }` that spans `R` such that
`Rᵣ →+* Sᵣ` is surjective. |
surjective_localRingHom_of_surjective {R S : Type u} [CommRing R] [CommRing S]
(f : R →+* S) (h : Function.Surjective f) (P : Ideal S) [P.IsPrime] :
Function.Surjective (Localization.localRingHom (P.comap f) P f rfl) :=
have : IsLocalization (Submonoid.map f (Ideal.comap f P).primeCompl) (Localization.AtPrime P) :=
(Submonoid.map_comap_eq_of_surjective h P.primeCompl).symm ▸ Localization.isLocalization
surjective_localizationPreserves _ _ _ _ h | theorem | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/Surjective.lean | surjective_localRingHom_of_surjective | A surjective ring homomorphism `R →+* S` induces a surjective homomorphism `R_{f⁻¹(P)} →+* S_P`
for every prime ideal `P` of `S`. |
@[algebraize Algebra.FormallyUnramified]
FormallyUnramified (f : R →+* S) : Prop :=
letI := f.toAlgebra
Algebra.FormallyUnramified R S | def | RingTheory | [
"Mathlib.RingTheory.Unramified.Locus",
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/Unramified.lean | FormallyUnramified | A ring homomorphism `R →+* A` is formally unramified if `Ω[A⁄R]` is trivial.
See `Algebra.FormallyUnramified`. |
formallyUnramified_algebraMap [Algebra R S] :
(algebraMap R S).FormallyUnramified ↔ Algebra.FormallyUnramified R S := by
rw [FormallyUnramified, toAlgebra_algebraMap] | lemma | RingTheory | [
"Mathlib.RingTheory.Unramified.Locus",
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/Unramified.lean | formallyUnramified_algebraMap | null |
stableUnderComposition :
StableUnderComposition FormallyUnramified := by
intro R S T _ _ _ f g _ _
algebraize [f, g, g.comp f]
exact .comp R S T | lemma | RingTheory | [
"Mathlib.RingTheory.Unramified.Locus",
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/Unramified.lean | stableUnderComposition | null |
respectsIso :
RespectsIso FormallyUnramified := by
refine stableUnderComposition.respectsIso ?_
intro R S _ _ e
letI := e.toRingHom.toAlgebra
exact Algebra.FormallyUnramified.of_surjective (Algebra.ofId R S) e.surjective | lemma | RingTheory | [
"Mathlib.RingTheory.Unramified.Locus",
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/Unramified.lean | respectsIso | null |
isStableUnderBaseChange :
IsStableUnderBaseChange FormallyUnramified := by
refine .mk respectsIso ?_
introv H
rw [formallyUnramified_algebraMap] at H ⊢
infer_instance | lemma | RingTheory | [
"Mathlib.RingTheory.Unramified.Locus",
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/Unramified.lean | isStableUnderBaseChange | null |
holdsForLocalizationAway :
HoldsForLocalizationAway FormallyUnramified := by
intro R S _ _ _ r _
rw [formallyUnramified_algebraMap]
exact .of_isLocalization (.powers r) | lemma | RingTheory | [
"Mathlib.RingTheory.Unramified.Locus",
"Mathlib.RingTheory.LocalProperties.Basic"
] | Mathlib/RingTheory/RingHom/Unramified.lean | holdsForLocalizationAway | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.