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 ⌀ |
|---|---|---|---|---|---|---|
_root_.Associated.normalizedFactors_eq {a b : α} (h : Associated a b) :
normalizedFactors a = normalizedFactors b := by
unfold normalizedFactors
have h' : ⇑(normalize (α := α)) = Associates.out ∘ Associates.mk := funext Associates.out_mk
rw [h', ← Multiset.map_map, ← Multiset.map_map,
Associates.rel_associated_iff_map_eq_map.mp (factors_rel_of_associated h)] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Basic",
"Mathlib.Data.Multiset.OrderedMonoid",
"Mathlib.RingTheory.UniqueFactorizationDomain.Basic"
] | Mathlib/RingTheory/UniqueFactorizationDomain/NormalizedFactors.lean | _root_.Associated.normalizedFactors_eq | null |
associated_iff_normalizedFactors_eq_normalizedFactors {x y : α} (hx : x ≠ 0) (hy : y ≠ 0) :
x ~ᵤ y ↔ normalizedFactors x = normalizedFactors y :=
⟨Associated.normalizedFactors_eq, fun h =>
(prod_normalizedFactors hx).symm.trans (_root_.trans (by rw [h]) (prod_normalizedFactors hy))⟩ | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Basic",
"Mathlib.Data.Multiset.OrderedMonoid",
"Mathlib.RingTheory.UniqueFactorizationDomain.Basic"
] | Mathlib/RingTheory/UniqueFactorizationDomain/NormalizedFactors.lean | associated_iff_normalizedFactors_eq_normalizedFactors | null |
normalizedFactors_of_irreducible_pow {p : α} (hp : Irreducible p) (k : ℕ) :
normalizedFactors (p ^ k) = Multiset.replicate k (normalize p) := by
rw [normalizedFactors_pow, normalizedFactors_irreducible hp, Multiset.nsmul_singleton] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Basic",
"Mathlib.Data.Multiset.OrderedMonoid",
"Mathlib.RingTheory.UniqueFactorizationDomain.Basic"
] | Mathlib/RingTheory/UniqueFactorizationDomain/NormalizedFactors.lean | normalizedFactors_of_irreducible_pow | null |
zero_notMem_normalizedFactors (x : α) : (0 : α) ∉ normalizedFactors x := fun h =>
Prime.ne_zero (prime_of_normalized_factor _ h) rfl
@[deprecated (since := "2025-05-23")]
alias zero_not_mem_normalizedFactors := zero_notMem_normalizedFactors | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Basic",
"Mathlib.Data.Multiset.OrderedMonoid",
"Mathlib.RingTheory.UniqueFactorizationDomain.Basic"
] | Mathlib/RingTheory/UniqueFactorizationDomain/NormalizedFactors.lean | zero_notMem_normalizedFactors | null |
dvd_of_mem_normalizedFactors {a p : α} (H : p ∈ normalizedFactors a) : p ∣ a := by
by_cases hcases : a = 0
· rw [hcases]
exact dvd_zero p
· exact dvd_trans (Multiset.dvd_prod H) (Associated.dvd (prod_normalizedFactors hcases))
@[deprecated (since := "2025-08-26")]
alias dvd_of_normalized_factor := dvd_of_mem_normalizedFactors | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Basic",
"Mathlib.Data.Multiset.OrderedMonoid",
"Mathlib.RingTheory.UniqueFactorizationDomain.Basic"
] | Mathlib/RingTheory/UniqueFactorizationDomain/NormalizedFactors.lean | dvd_of_mem_normalizedFactors | null |
mem_normalizedFactors_iff [Subsingleton αˣ] {p x : α} (hx : x ≠ 0) :
p ∈ normalizedFactors x ↔ Prime p ∧ p ∣ x := by
constructor
· intro h
exact ⟨prime_of_normalized_factor p h, dvd_of_mem_normalizedFactors h⟩
· rintro ⟨hprime, hdvd⟩
obtain ⟨q, hqmem, hqeq⟩ := exists_mem_normalizedFactors_of_dvd hx hprime.irreducible hdvd
rw [associated_iff_eq] at hqeq
exact hqeq ▸ hqmem | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Basic",
"Mathlib.Data.Multiset.OrderedMonoid",
"Mathlib.RingTheory.UniqueFactorizationDomain.Basic"
] | Mathlib/RingTheory/UniqueFactorizationDomain/NormalizedFactors.lean | mem_normalizedFactors_iff | null |
mem_normalizedFactors_iff' {p x : α} (h : x ≠ 0) :
p ∈ normalizedFactors x ↔ Irreducible p ∧ normalize p = p ∧ p ∣ x := by
refine ⟨fun h ↦ ⟨irreducible_of_normalized_factor p h, normalize_normalized_factor p h,
dvd_of_mem_normalizedFactors h⟩, fun ⟨h₁, h₂, h₃⟩ ↦ ?_⟩
obtain ⟨y, hy₁, hy₂⟩ := exists_mem_factors_of_dvd h h₁ h₃
exact Multiset.mem_map.mpr ⟨y, hy₁, by
rwa [← h₂, normalize_eq_normalize_iff_associated, Associated.comm]⟩ | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Basic",
"Mathlib.Data.Multiset.OrderedMonoid",
"Mathlib.RingTheory.UniqueFactorizationDomain.Basic"
] | Mathlib/RingTheory/UniqueFactorizationDomain/NormalizedFactors.lean | mem_normalizedFactors_iff' | null |
disjoint_normalizedFactors {a b : α} (hc : IsRelPrime a b) :
Disjoint (normalizedFactors a) (normalizedFactors b) := by
rw [Multiset.disjoint_left]
intro x hxa hxb
have x_dvd_a := dvd_of_mem_normalizedFactors hxa
have x_dvd_b := dvd_of_mem_normalizedFactors hxb
exact (prime_of_normalized_factor x hxa).not_unit (hc x_dvd_a x_dvd_b) | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Basic",
"Mathlib.Data.Multiset.OrderedMonoid",
"Mathlib.RingTheory.UniqueFactorizationDomain.Basic"
] | Mathlib/RingTheory/UniqueFactorizationDomain/NormalizedFactors.lean | disjoint_normalizedFactors | Relatively prime elements have disjoint prime factors (as multisets). |
exists_associated_prime_pow_of_unique_normalized_factor {p r : α}
(h : ∀ {m}, m ∈ normalizedFactors r → m = p) (hr : r ≠ 0) : ∃ i : ℕ, Associated (p ^ i) r := by
use (normalizedFactors r).card
have := UniqueFactorizationMonoid.prod_normalizedFactors hr
rwa [Multiset.eq_replicate_of_mem fun b => h, Multiset.prod_replicate] at this | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Basic",
"Mathlib.Data.Multiset.OrderedMonoid",
"Mathlib.RingTheory.UniqueFactorizationDomain.Basic"
] | Mathlib/RingTheory/UniqueFactorizationDomain/NormalizedFactors.lean | exists_associated_prime_pow_of_unique_normalized_factor | null |
normalizedFactors_prod_of_prime [Subsingleton αˣ] {m : Multiset α}
(h : ∀ p ∈ m, Prime p) : normalizedFactors m.prod = m := by
cases subsingleton_or_nontrivial α
· obtain rfl : m = 0 := by
refine Multiset.eq_zero_of_forall_notMem fun x hx ↦ ?_
simpa [Subsingleton.elim x 0] using h x hx
simp
· simpa only [← Multiset.rel_eq, ← associated_eq_eq] using
prime_factors_unique prime_of_normalized_factor h
(prod_normalizedFactors (m.prod_ne_zero_of_prime h)) | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Basic",
"Mathlib.Data.Multiset.OrderedMonoid",
"Mathlib.RingTheory.UniqueFactorizationDomain.Basic"
] | Mathlib/RingTheory/UniqueFactorizationDomain/NormalizedFactors.lean | normalizedFactors_prod_of_prime | null |
mem_normalizedFactors_eq_of_associated {a b c : α} (ha : a ∈ normalizedFactors c)
(hb : b ∈ normalizedFactors c) (h : Associated a b) : a = b := by
rw [← normalize_normalized_factor a ha, ← normalize_normalized_factor b hb,
normalize_eq_normalize_iff]
exact Associated.dvd_dvd h
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Basic",
"Mathlib.Data.Multiset.OrderedMonoid",
"Mathlib.RingTheory.UniqueFactorizationDomain.Basic"
] | Mathlib/RingTheory/UniqueFactorizationDomain/NormalizedFactors.lean | mem_normalizedFactors_eq_of_associated | null |
normalizedFactors_pos (x : α) (hx : x ≠ 0) : 0 < normalizedFactors x ↔ ¬IsUnit x := by
constructor
· intro h hx
obtain ⟨p, hp⟩ := Multiset.exists_mem_of_ne_zero h.ne'
exact
(prime_of_normalized_factor _ hp).not_unit
(isUnit_of_dvd_unit (dvd_of_mem_normalizedFactors hp) hx)
· intro h
obtain ⟨p, hp⟩ := exists_mem_normalizedFactors hx h
exact
bot_lt_iff_ne_bot.mpr
(mt Multiset.eq_zero_iff_forall_notMem.mp (not_forall.mpr ⟨p, not_not.mpr hp⟩)) | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Basic",
"Mathlib.Data.Multiset.OrderedMonoid",
"Mathlib.RingTheory.UniqueFactorizationDomain.Basic"
] | Mathlib/RingTheory/UniqueFactorizationDomain/NormalizedFactors.lean | normalizedFactors_pos | null |
normalizedFactors_eq_zero_iff {x : α} (hx : x ≠ 0) :
normalizedFactors x = 0 ↔ IsUnit x := by
rw [← not_iff_not, ← normalizedFactors_pos _ hx, pos_iff_ne_zero] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Basic",
"Mathlib.Data.Multiset.OrderedMonoid",
"Mathlib.RingTheory.UniqueFactorizationDomain.Basic"
] | Mathlib/RingTheory/UniqueFactorizationDomain/NormalizedFactors.lean | normalizedFactors_eq_zero_iff | The multiset of normalized factors of `x` is nil if and only if `x` is a unit.
The converse is true without the nonzero assumption, see `normalizedFactors_of_isUnit`. |
normalizedFactors_of_isUnit {x : α} (hx : IsUnit x) :
normalizedFactors x = 0 := by
obtain rfl | hx₀ := eq_or_ne x 0
· simp
rwa [normalizedFactors_eq_zero_iff hx₀] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Basic",
"Mathlib.Data.Multiset.OrderedMonoid",
"Mathlib.RingTheory.UniqueFactorizationDomain.Basic"
] | Mathlib/RingTheory/UniqueFactorizationDomain/NormalizedFactors.lean | normalizedFactors_of_isUnit | If `x` is a unit, then the multiset of normalized factors of `x` is nil.
The converse is true with a nonzero assumption, see `normalizedFactors_eq_zero_iff`. |
dvdNotUnit_iff_normalizedFactors_lt_normalizedFactors {x y : α} (hx : x ≠ 0) (hy : y ≠ 0) :
DvdNotUnit x y ↔ normalizedFactors x < normalizedFactors y := by
constructor
· rintro ⟨_, c, hc, rfl⟩
simp only [hx, right_ne_zero_of_mul hy, normalizedFactors_mul, Ne, not_false_iff,
lt_add_iff_pos_right, normalizedFactors_pos, hc]
· intro h
exact
dvdNotUnit_of_dvd_of_not_dvd
((dvd_iff_normalizedFactors_le_normalizedFactors hx hy).mpr h.le)
(mt (dvd_iff_normalizedFactors_le_normalizedFactors hy hx).mp h.not_ge) | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Basic",
"Mathlib.Data.Multiset.OrderedMonoid",
"Mathlib.RingTheory.UniqueFactorizationDomain.Basic"
] | Mathlib/RingTheory/UniqueFactorizationDomain/NormalizedFactors.lean | dvdNotUnit_iff_normalizedFactors_lt_normalizedFactors | null |
normalizedFactors_multiset_prod (s : Multiset α) (hs : 0 ∉ s) :
normalizedFactors (s.prod) = (s.map normalizedFactors).sum := by
cases subsingleton_or_nontrivial α
· obtain rfl : s = 0 := by
apply Multiset.eq_zero_of_forall_notMem
intro _
convert hs
simp
induction s using Multiset.induction with
| empty => simp
| cons _ _ IH =>
rw [Multiset.prod_cons, Multiset.map_cons, Multiset.sum_cons, normalizedFactors_mul, IH]
· exact fun h ↦ hs (Multiset.mem_cons_of_mem h)
· exact fun h ↦ hs (h ▸ Multiset.mem_cons_self _ _)
· apply Multiset.prod_ne_zero
exact fun h ↦ hs (Multiset.mem_cons_of_mem h)
variable {β : Type*} [CancelCommMonoidWithZero β] [NormalizationMonoid β]
[UniqueFactorizationMonoid β] {F : Type*} [EquivLike F α β] [MulEquivClass F α β] {f : F} | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Basic",
"Mathlib.Data.Multiset.OrderedMonoid",
"Mathlib.RingTheory.UniqueFactorizationDomain.Basic"
] | Mathlib/RingTheory/UniqueFactorizationDomain/NormalizedFactors.lean | normalizedFactors_multiset_prod | null |
normalizedFactorsEquiv (he : ∀ x, normalize (f x) = f (normalize x)) (a : α) :
{x // x ∈ normalizedFactors a} ≃ {y // y ∈ normalizedFactors (f a)} :=
Equiv.subtypeEquiv f fun x ↦ by
rcases eq_or_ne a 0 with rfl | ha
· simp
· simp [mem_normalizedFactors_iff' ha,
mem_normalizedFactors_iff' (EmbeddingLike.map_ne_zero_iff.mpr ha), map_dvd_iff_dvd_symm,
MulEquiv.irreducible_iff, he]
@[simp] | def | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Basic",
"Mathlib.Data.Multiset.OrderedMonoid",
"Mathlib.RingTheory.UniqueFactorizationDomain.Basic"
] | Mathlib/RingTheory/UniqueFactorizationDomain/NormalizedFactors.lean | normalizedFactorsEquiv | If the monoid equiv `f : α ≃* β` commutes with `normalize` then, for `a : α`, it yields a
bijection between the `normalizedFactors` of `a` and of `f a`. |
normalizedFactorsEquiv_apply (he : ∀ x, normalize (f x) = f (normalize x))
{a p : α} (hp : p ∈ normalizedFactors a) :
normalizedFactorsEquiv he a ⟨p, hp⟩ = f p := rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Basic",
"Mathlib.Data.Multiset.OrderedMonoid",
"Mathlib.RingTheory.UniqueFactorizationDomain.Basic"
] | Mathlib/RingTheory/UniqueFactorizationDomain/NormalizedFactors.lean | normalizedFactorsEquiv_apply | null |
normalizedFactorsEquiv_symm_apply (he : ∀ x, normalize (f x) = f (normalize x))
{a : α} {q : β} (hq : q ∈ normalizedFactors (f a)) :
(normalizedFactorsEquiv he a).symm ⟨q, hq⟩ = (MulEquivClass.toMulEquiv f).symm q := rfl | theorem | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Basic",
"Mathlib.Data.Multiset.OrderedMonoid",
"Mathlib.RingTheory.UniqueFactorizationDomain.Basic"
] | Mathlib/RingTheory/UniqueFactorizationDomain/NormalizedFactors.lean | normalizedFactorsEquiv_symm_apply | null |
protected noncomputable normalizationMonoid : NormalizationMonoid α :=
normalizationMonoidOfMonoidHomRightInverse
{ toFun := fun a : Associates α =>
if a = 0 then 0
else
((normalizedFactors a).map
(Classical.choose mk_surjective.hasRightInverse : Associates α → α)).prod
map_one' := by nontriviality α; simp
map_mul' := fun x y => by
by_cases hx : x = 0
· simp [hx]
by_cases hy : y = 0
· simp [hy]
simp [hx, hy] }
(by
intro x
dsimp
by_cases hx : x = 0
· simp [hx]
have h : Associates.mkMonoidHom ∘ Classical.choose mk_surjective.hasRightInverse =
(id : Associates α → Associates α) := by
ext x
rw [Function.comp_apply, mkMonoidHom_apply,
Classical.choose_spec mk_surjective.hasRightInverse x]
rfl
rw [if_neg hx, ← mkMonoidHom_apply, MonoidHom.map_multiset_prod, map_map, h, map_id, ←
associated_iff_eq]
apply prod_normalizedFactors hx) | def | RingTheory | [
"Mathlib.Algebra.GCDMonoid.Basic",
"Mathlib.Data.Multiset.OrderedMonoid",
"Mathlib.RingTheory.UniqueFactorizationDomain.Basic"
] | Mathlib/RingTheory/UniqueFactorizationDomain/NormalizedFactors.lean | normalizationMonoid | Noncomputably defines a `normalizationMonoid` structure on a `UniqueFactorizationMonoid`. |
@[mk_iff, stacks 00UM]
FormallyUnramified : Prop where
subsingleton_kaehlerDifferential : Subsingleton Ω[A⁄R]
attribute [instance] FormallyUnramified.subsingleton_kaehlerDifferential | class | RingTheory | [
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot"
] | Mathlib/RingTheory/Unramified/Basic.lean | FormallyUnramified | An `R`-algebra `A` is formally unramified if `Ω[A⁄R]` is trivial.
This is equivalent to "for every `R`-algebra, every square-zero ideal
`I : Ideal B` and `f : A →ₐ[R] B ⧸ I`, there exists at most one lift `A →ₐ[R] B`".
See `Algebra.FormallyUnramified.iff_comp_injective`. |
comp_injective [FormallyUnramified R A] (hI : I ^ 2 = ⊥) :
Function.Injective ((Ideal.Quotient.mkₐ R I).comp : (A →ₐ[R] B) → A →ₐ[R] B ⧸ I) := by
intro f₁ f₂ e
letI := f₁.toRingHom.toAlgebra
haveI := IsScalarTower.of_algebraMap_eq' f₁.comp_algebraMap.symm
have :=
((KaehlerDifferential.linearMapEquivDerivation R A).toEquiv.trans
(derivationToSquareZeroEquivLift I hI)).surjective.subsingleton
exact Subtype.ext_iff.mp (@Subsingleton.elim _ this ⟨f₁, rfl⟩ ⟨f₂, e.symm⟩) | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot"
] | Mathlib/RingTheory/Unramified/Basic.lean | comp_injective | null |
iff_comp_injective :
FormallyUnramified R A ↔
∀ ⦃B : Type u⦄ [CommRing B],
∀ [Algebra R B] (I : Ideal B) (_ : I ^ 2 = ⊥),
Function.Injective ((Ideal.Quotient.mkₐ R I).comp : (A →ₐ[R] B) → A →ₐ[R] B ⧸ I) := by
constructor
· intros; exact comp_injective _ ‹_›
· intro H
constructor
by_contra! h
obtain ⟨f₁, f₂, e⟩ := (KaehlerDifferential.endEquiv R A).injective.nontrivial
apply e
ext1
refine H
(RingHom.ker (TensorProduct.lmul' R (S := A)).kerSquareLift.toRingHom) ?_ ?_
· rw [AlgHom.ker_kerSquareLift]
exact Ideal.cotangentIdeal_square _
· ext x
apply RingHom.kerLift_injective (TensorProduct.lmul' R (S := A)).kerSquareLift.toRingHom
simpa using DFunLike.congr_fun (f₁.2.trans f₂.2.symm) x | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot"
] | Mathlib/RingTheory/Unramified/Basic.lean | iff_comp_injective | null |
lift_unique
[FormallyUnramified R A] (I : Ideal B) (hI : IsNilpotent I) (g₁ g₂ : A →ₐ[R] B)
(h : (Ideal.Quotient.mkₐ R I).comp g₁ = (Ideal.Quotient.mkₐ R I).comp g₂) : g₁ = g₂ := by
revert g₁ g₂
change Function.Injective (Ideal.Quotient.mkₐ R I).comp
revert ‹Algebra R B›
apply Ideal.IsNilpotent.induction_on (S := B) I hI
· intro B _ I hI _; exact FormallyUnramified.comp_injective I hI
· intro B _ I J hIJ h₁ h₂ _ g₁ g₂ e
apply h₁
apply h₂
ext x
replace e := AlgHom.congr_fun e x
dsimp only [AlgHom.comp_apply, Ideal.Quotient.mkₐ_eq_mk] at e ⊢
rwa [Ideal.Quotient.eq, ← map_sub, Ideal.mem_quotient_iff_mem hIJ, ← Ideal.Quotient.eq] | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot"
] | Mathlib/RingTheory/Unramified/Basic.lean | lift_unique | null |
ext [FormallyUnramified R A] (hI : IsNilpotent I) {g₁ g₂ : A →ₐ[R] B}
(H : ∀ x, Ideal.Quotient.mk I (g₁ x) = Ideal.Quotient.mk I (g₂ x)) : g₁ = g₂ :=
FormallyUnramified.lift_unique I hI g₁ g₂ (AlgHom.ext H) | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot"
] | Mathlib/RingTheory/Unramified/Basic.lean | ext | null |
lift_unique_of_ringHom [FormallyUnramified R A] {C : Type*} [Ring C]
(f : B →+* C) (hf : IsNilpotent <| RingHom.ker f) (g₁ g₂ : A →ₐ[R] B)
(h : f.comp ↑g₁ = f.comp (g₂ : A →+* B)) : g₁ = g₂ :=
FormallyUnramified.lift_unique _ hf _ _
(by
ext x
have := RingHom.congr_fun h x
simpa only [Ideal.Quotient.eq, Function.comp_apply, AlgHom.coe_comp, Ideal.Quotient.mkₐ_eq_mk,
RingHom.mem_ker, map_sub, sub_eq_zero]) | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot"
] | Mathlib/RingTheory/Unramified/Basic.lean | lift_unique_of_ringHom | null |
ext' [FormallyUnramified R A] {C : Type*} [Ring C] (f : B →+* C)
(hf : IsNilpotent <| RingHom.ker f) (g₁ g₂ : A →ₐ[R] B) (h : ∀ x, f (g₁ x) = f (g₂ x)) :
g₁ = g₂ :=
FormallyUnramified.lift_unique_of_ringHom f hf g₁ g₂ (RingHom.ext h) | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot"
] | Mathlib/RingTheory/Unramified/Basic.lean | ext' | null |
lift_unique' [FormallyUnramified R A] {C : Type*} [Ring C]
[Algebra R C] (f : B →ₐ[R] C) (hf : IsNilpotent <| RingHom.ker (f : B →+* C))
(g₁ g₂ : A →ₐ[R] B) (h : f.comp g₁ = f.comp g₂) : g₁ = g₂ :=
FormallyUnramified.ext' _ hf g₁ g₂ (AlgHom.congr_fun h) | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot"
] | Mathlib/RingTheory/Unramified/Basic.lean | lift_unique' | null |
ext_of_iInf [FormallyUnramified R A] (hI : ⨅ i, I ^ i = ⊥) {g₁ g₂ : A →ₐ[R] B}
(H : ∀ x, Ideal.Quotient.mk I (g₁ x) = Ideal.Quotient.mk I (g₂ x)) : g₁ = g₂ := by
have (i : ℕ) :
(Ideal.Quotient.mkₐ R (I ^ i)).comp g₁ = (Ideal.Quotient.mkₐ R (I ^ i)).comp g₂ := by
by_cases hi : i = 0
· ext x
have : Subsingleton (B ⧸ I ^ i) := by
rw [hi, pow_zero, Ideal.one_eq_top]
infer_instance
exact Subsingleton.elim _ _
apply ext (I.map (algebraMap _ _)) ⟨i, by simp [← Ideal.map_pow]⟩
intro x
dsimp
rw [Ideal.Quotient.eq, ← map_sub, ← Ideal.mem_comap, Ideal.comap_map_of_surjective',
sup_eq_left.mpr, ← Ideal.Quotient.eq]
· exact H _
· simpa using Ideal.pow_le_self hi
· exact Ideal.Quotient.mk_surjective
ext x
rw [← sub_eq_zero, ← Ideal.mem_bot, ← hI, Ideal.mem_iInf]
intro i
rw [← Ideal.Quotient.eq_zero_iff_mem, map_sub, sub_eq_zero]
exact DFunLike.congr_fun (this i) x | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot"
] | Mathlib/RingTheory/Unramified/Basic.lean | ext_of_iInf | null |
of_equiv [FormallyUnramified R A] (e : A ≃ₐ[R] B) :
FormallyUnramified R B := by
rw [iff_comp_injective]
intro C _ _ I hI f₁ f₂ e'
rw [← f₁.comp_id, ← f₂.comp_id, ← e.comp_symm, ← AlgHom.comp_assoc, ← AlgHom.comp_assoc]
congr 1
refine FormallyUnramified.comp_injective I hI ?_
rw [← AlgHom.comp_assoc, e', AlgHom.comp_assoc] | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot"
] | Mathlib/RingTheory/Unramified/Basic.lean | of_equiv | null |
comp [FormallyUnramified R A] [FormallyUnramified A B] :
FormallyUnramified R B := by
rw [iff_comp_injective]
intro C _ _ I hI f₁ f₂ e
have e' :=
FormallyUnramified.lift_unique I ⟨2, hI⟩ (f₁.comp <| IsScalarTower.toAlgHom R A B)
(f₂.comp <| IsScalarTower.toAlgHom R A B) (by rw [← AlgHom.comp_assoc, e, AlgHom.comp_assoc])
letI := (f₁.restrictDomain A).toAlgebra
let F₁ : B →ₐ[A] C := { f₁ with commutes' := fun r => rfl }
let F₂ : B →ₐ[A] C := { f₂ with commutes' := AlgHom.congr_fun e'.symm }
ext1 x
change F₁ x = F₂ x
congr
exact FormallyUnramified.ext I ⟨2, hI⟩ (AlgHom.congr_fun e) | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot"
] | Mathlib/RingTheory/Unramified/Basic.lean | comp | null |
of_comp [FormallyUnramified R B] : FormallyUnramified A B := by
rw [iff_comp_injective]
intro Q _ _ I e f₁ f₂ e'
letI := ((algebraMap A Q).comp (algebraMap R A)).toAlgebra
letI : IsScalarTower R A Q := IsScalarTower.of_algebraMap_eq' rfl
refine AlgHom.restrictScalars_injective R ?_
refine FormallyUnramified.ext I ⟨2, e⟩ ?_
intro x
exact AlgHom.congr_fun e' x | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot"
] | Mathlib/RingTheory/Unramified/Basic.lean | of_comp | null |
of_surjective [FormallyUnramified R A] (f : A →ₐ[R] B) (H : Function.Surjective f) :
FormallyUnramified R B := by
rw [iff_comp_injective]
intro Q _ _ I hI f₁ f₂ e
ext x
obtain ⟨x, rfl⟩ := H x
rw [← AlgHom.comp_apply, ← AlgHom.comp_apply]
congr 1
apply FormallyUnramified.comp_injective I hI
ext x; exact DFunLike.congr_fun e (f x) | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot"
] | Mathlib/RingTheory/Unramified/Basic.lean | of_surjective | This holds in general for epimorphisms. |
quotient {A} [CommRing A] [Algebra R A] [FormallyUnramified R A] (I : Ideal A) :
FormallyUnramified R (A ⧸ I) :=
FormallyUnramified.of_surjective (IsScalarTower.toAlgHom R A (A ⧸ I)) Ideal.Quotient.mk_surjective | instance | RingTheory | [
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot"
] | Mathlib/RingTheory/Unramified/Basic.lean | quotient | null |
iff_of_equiv (e : A ≃ₐ[R] B) : FormallyUnramified R A ↔ FormallyUnramified R B :=
⟨fun _ ↦ of_equiv e, fun _ ↦ of_equiv e.symm⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot"
] | Mathlib/RingTheory/Unramified/Basic.lean | iff_of_equiv | null |
base_change [FormallyUnramified R A] :
FormallyUnramified B (B ⊗[R] A) := by
rw [iff_comp_injective]
intro C _ _ I hI f₁ f₂ e
letI := ((algebraMap B C).comp (algebraMap R B)).toAlgebra
haveI : IsScalarTower R B C := IsScalarTower.of_algebraMap_eq' rfl
ext : 1
· subsingleton
· exact FormallyUnramified.ext I ⟨2, hI⟩ fun x => AlgHom.congr_fun e (1 ⊗ₜ x) | instance | RingTheory | [
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot"
] | Mathlib/RingTheory/Unramified/Basic.lean | base_change | null |
of_isLocalization [IsLocalization M Rₘ] : FormallyUnramified R Rₘ := by
rw [iff_comp_injective]
intro Q _ _ I _ f₁ f₂ _
apply AlgHom.coe_ringHom_injective
refine IsLocalization.ringHom_ext M ?_
ext
simp | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot"
] | Mathlib/RingTheory/Unramified/Basic.lean | of_isLocalization | This holds in general for epimorphisms. |
@[nolint unusedArguments]
localization_base [FormallyUnramified R Sₘ] : FormallyUnramified Rₘ Sₘ :=
FormallyUnramified.of_comp R Rₘ Sₘ | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot"
] | Mathlib/RingTheory/Unramified/Basic.lean | localization_base | This actually does not need the localization instance, and is stated here again for
consistency. See `Algebra.FormallyUnramified.of_comp` instead.
The intended use is for copying proofs between `Formally{Unramified, Smooth, Etale}`
without the need to change anything (including removing redundant arguments). |
localization_map [FormallyUnramified R S] :
FormallyUnramified Rₘ Sₘ := by
haveI : FormallyUnramified S Sₘ :=
FormallyUnramified.of_isLocalization (M.map (algebraMap R S))
haveI : FormallyUnramified R Sₘ := FormallyUnramified.comp R S Sₘ
exact FormallyUnramified.localization_base M | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot"
] | Mathlib/RingTheory/Unramified/Basic.lean | localization_map | null |
@[stacks 00UT "Note that the Stacks project has a different definition of unramified, and tag
<https://stacks.math.columbia.edu/tag/00UU> shows that their definition is the same as this one."]
Unramified : Prop where
formallyUnramified : FormallyUnramified R A := by infer_instance
finiteType : FiniteType R A := by infer_instance | class | RingTheory | [
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot"
] | Mathlib/RingTheory/Unramified/Basic.lean | Unramified | An `R`-algebra `A` is unramified if it is formally unramified and of finite type. |
of_equiv [Unramified R A] (e : A ≃ₐ[R] B) : Unramified R B where
formallyUnramified := FormallyUnramified.of_equiv e
finiteType := FiniteType.equiv Unramified.finiteType e | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot"
] | Mathlib/RingTheory/Unramified/Basic.lean | of_equiv | Being unramified is transported via algebra isomorphisms. |
of_isLocalization_Away (r : R) [IsLocalization.Away r A] : Unramified R A where
formallyUnramified := Algebra.FormallyUnramified.of_isLocalization (Submonoid.powers r)
finiteType :=
haveI : FinitePresentation R A := IsLocalization.Away.finitePresentation r
inferInstance | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot"
] | Mathlib/RingTheory/Unramified/Basic.lean | of_isLocalization_Away | Localization at an element is unramified. |
comp [Algebra A B] [IsScalarTower R A B] [Unramified R A] [Unramified A B] :
Unramified R B where
formallyUnramified := FormallyUnramified.comp R A B
finiteType := FiniteType.trans (S := A) Unramified.finiteType
Unramified.finiteType | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot"
] | Mathlib/RingTheory/Unramified/Basic.lean | comp | Unramified is stable under composition. |
baseChange [Unramified R A] : Unramified B (B ⊗[R] A) where | instance | RingTheory | [
"Mathlib.RingTheory.FiniteStability",
"Mathlib.RingTheory.Ideal.Quotient.Nilpotent",
"Mathlib.RingTheory.Kaehler.Basic",
"Mathlib.RingTheory.Localization.Away.AdjoinRoot"
] | Mathlib/RingTheory/Unramified/Basic.lean | baseChange | Unramified is stable under base change. |
of_isSeparable [Algebra.IsSeparable K L] : FormallyUnramified K L := by
rw [iff_comp_injective]
intro B _ _ I hI f₁ f₂ e
ext x
have : f₁ x - f₂ x ∈ I := by
simpa [Ideal.Quotient.mk_eq_mk_iff_sub_mem] using AlgHom.congr_fun e x
have := Polynomial.eval_add_of_sq_eq_zero ((minpoly K x).map (algebraMap K B)) (f₂ x)
(f₁ x - f₂ x) (show (f₁ x - f₂ x) ^ 2 ∈ ⊥ from hI ▸ Ideal.pow_mem_pow this 2)
simp only [add_sub_cancel, eval_map_algebraMap, aeval_algHom_apply, minpoly.aeval, map_zero,
derivative_map, zero_add] at this
rwa [eq_comm, ((isUnit_iff_ne_zero.mpr
((Algebra.IsSeparable.isSeparable K x).aeval_derivative_ne_zero
(minpoly.aeval K x))).map f₂).mul_right_eq_zero, sub_eq_zero] at this
variable [FormallyUnramified K A] [EssFiniteType K A]
variable [FormallyUnramified K L] [EssFiniteType K L] | theorem | RingTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.RingTheory.Artinian.Ring",
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.Algebra.Polynomial.Taylor",
"Mathlib.RingTheory.Unramified.Finite"
] | Mathlib/RingTheory/Unramified/Field.lean | of_isSeparable | null |
bijective_of_isAlgClosed_of_isLocalRing
[IsAlgClosed K] [IsLocalRing A] :
Function.Bijective (algebraMap K A) := by
have := finite_of_free (R := K) (S := A)
have : IsArtinianRing A := isArtinian_of_tower K inferInstance
have hA : IsNilpotent (IsLocalRing.maximalIdeal A) := by
rw [← IsLocalRing.jacobson_eq_maximalIdeal ⊥]
· exact IsArtinianRing.isNilpotent_jacobson_bot
· exact bot_ne_top
let e : K ≃ₐ[K] A ⧸ IsLocalRing.maximalIdeal A := {
__ := Algebra.ofId K (A ⧸ IsLocalRing.maximalIdeal A)
__ := Equiv.ofBijective _ IsAlgClosed.algebraMap_bijective_of_isIntegral }
let e' : A ⊗[K] (A ⧸ IsLocalRing.maximalIdeal A) ≃ₐ[A] A :=
(Algebra.TensorProduct.congr AlgEquiv.refl e.symm).trans (Algebra.TensorProduct.rid K A A)
let f : A ⧸ IsLocalRing.maximalIdeal A →ₗ[A] A := e'.toLinearMap.comp (sec K A _)
have hf : (Algebra.ofId _ _).toLinearMap ∘ₗ f = LinearMap.id := by
dsimp [f]
rw [← LinearMap.comp_assoc, ← comp_sec K A]
congr 1
apply LinearMap.restrictScalars_injective K
apply _root_.TensorProduct.ext'
intro r s
obtain ⟨s, rfl⟩ := e.surjective s
suffices s • (Ideal.Quotient.mk (IsLocalRing.maximalIdeal A)) r = r • e s by
simpa [ofId, e']
simp [Algebra.smul_def, e, ofId, mul_comm]
have hf₁ : f 1 • (1 : A ⧸ IsLocalRing.maximalIdeal A) = 1 := by
rw [← algebraMap_eq_smul_one]
exact LinearMap.congr_fun hf 1
have hf₂ : 1 - f 1 ∈ IsLocalRing.maximalIdeal A := by
rw [← Ideal.Quotient.eq_zero_iff_mem, map_sub, map_one, ← Ideal.Quotient.algebraMap_eq,
algebraMap_eq_smul_one, hf₁, sub_self]
have hf₃ : IsIdempotentElem (1 - f 1) := by
apply IsIdempotentElem.one_sub
rw [IsIdempotentElem, ← smul_eq_mul, ← map_smul, hf₁]
have hf₄ : f 1 = 1 := by
obtain ⟨n, hn⟩ := hA
have : (1 - f 1) ^ n = 0 := by
rw [← Ideal.mem_bot, ← Ideal.zero_eq_bot, ← hn]
exact Ideal.pow_mem_pow hf₂ n
rw [eq_comm, ← sub_eq_zero, ← hf₃.pow_succ_eq n, pow_succ, this, zero_mul]
refine Equiv.bijective ⟨algebraMap K A, ⇑e.symm ∘ ⇑(algebraMap A _), fun x ↦ by simp, fun x ↦ ?_⟩
have : ⇑(algebraMap K A) = ⇑f ∘ ⇑e := by
ext k
conv_rhs => rw [← mul_one k, ← smul_eq_mul, Function.comp_apply, map_smul,
LinearMap.map_smul_of_tower, map_one, hf₄, ← algebraMap_eq_smul_one]
rw [this]
simp only [Function.comp_apply, AlgEquiv.apply_symm_apply, algebraMap_eq_smul_one,
map_smul, hf₄, smul_eq_mul, mul_one] | theorem | RingTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.RingTheory.Artinian.Ring",
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.Algebra.Polynomial.Taylor",
"Mathlib.RingTheory.Unramified.Finite"
] | Mathlib/RingTheory/Unramified/Field.lean | bijective_of_isAlgClosed_of_isLocalRing | null |
isField_of_isAlgClosed_of_isLocalRing
[IsAlgClosed K] [IsLocalRing A] : IsField A := by
rw [IsLocalRing.isField_iff_maximalIdeal_eq, eq_bot_iff]
intro x hx
obtain ⟨x, rfl⟩ := (bijective_of_isAlgClosed_of_isLocalRing K A).surjective x
change _ = 0
rw [← (algebraMap K A).map_zero]
by_contra hx'
exact hx ((isUnit_iff_ne_zero.mpr
(fun e ↦ hx' ((algebraMap K A).congr_arg e))).map (algebraMap K A))
include K in | theorem | RingTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.RingTheory.Artinian.Ring",
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.Algebra.Polynomial.Taylor",
"Mathlib.RingTheory.Unramified.Finite"
] | Mathlib/RingTheory/Unramified/Field.lean | isField_of_isAlgClosed_of_isLocalRing | null |
isReduced_of_field :
IsReduced A := by
constructor
intro x hx
let f := (Algebra.TensorProduct.includeRight (R := K) (A := AlgebraicClosure K) (B := A))
have : Function.Injective f := by
have : ⇑f = (LinearMap.rTensor A (Algebra.ofId K (AlgebraicClosure K)).toLinearMap).comp
(Algebra.TensorProduct.lid K A).symm.toLinearMap := by
ext x; simp [f]
rw [this]
suffices Function.Injective
(LinearMap.rTensor A (Algebra.ofId K (AlgebraicClosure K)).toLinearMap) by
exact this.comp (Algebra.TensorProduct.lid K A).symm.injective
apply Module.Flat.rTensor_preserves_injective_linearMap
exact (algebraMap K _).injective
apply this
rw [map_zero]
apply eq_zero_of_localization
intro M hM
have hy := (hx.map f).map (algebraMap _ (Localization.AtPrime M))
generalize algebraMap _ (Localization.AtPrime M) (f x) = y at *
have := EssFiniteType.of_isLocalization (Localization.AtPrime M) M.primeCompl
have := of_isLocalization (Rₘ := Localization.AtPrime M) M.primeCompl
have := EssFiniteType.comp (AlgebraicClosure K) (AlgebraicClosure K ⊗[K] A)
(Localization.AtPrime M)
have := comp (AlgebraicClosure K) (AlgebraicClosure K ⊗[K] A)
(Localization.AtPrime M)
letI := (isField_of_isAlgClosed_of_isLocalRing (AlgebraicClosure K)
(A := Localization.AtPrime M)).toField
exact hy.eq_zero | theorem | RingTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.RingTheory.Artinian.Ring",
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.Algebra.Polynomial.Taylor",
"Mathlib.RingTheory.Unramified.Finite"
] | Mathlib/RingTheory/Unramified/Field.lean | isReduced_of_field | null |
range_eq_top_of_isPurelyInseparable
[IsPurelyInseparable K L] : (algebraMap K L).range = ⊤ := by
classical
have : Nontrivial (L ⊗[K] L) := by
rw [← not_subsingleton_iff_nontrivial, ← rank_zero_iff (R := K), rank_tensorProduct',
mul_eq_zero, or_self, rank_zero_iff, not_subsingleton_iff_nontrivial]
infer_instance
rw [← top_le_iff]
intro x _
obtain ⟨n, hn⟩ := IsPurelyInseparable.pow_mem K (ringExpChar K) x
have : ExpChar (L ⊗[K] L) (ringExpChar K) := by
refine expChar_of_injective_ringHom (algebraMap K _).injective (ringExpChar K)
have : (1 ⊗ₜ x - x ⊗ₜ 1 : L ⊗[K] L) ^ (ringExpChar K) ^ n = 0 := by
rw [sub_pow_expChar_pow, TensorProduct.tmul_pow, one_pow, TensorProduct.tmul_pow, one_pow]
obtain ⟨r, hr⟩ := hn
rw [← hr, algebraMap_eq_smul_one, TensorProduct.smul_tmul, sub_self]
have H : (1 ⊗ₜ x : L ⊗[K] L) = x ⊗ₜ 1 := by
have inst : IsReduced (L ⊗[K] L) := isReduced_of_field L _
exact sub_eq_zero.mp (IsNilpotent.eq_zero ⟨_, this⟩)
by_cases h' : LinearIndependent K ![1, x]
· have h := h'.linearIndepOn_id
let S := h.extend (Set.subset_univ _)
let a : S := ⟨1, h.subset_extend _ (by simp)⟩
have ha : Basis.extend h a = 1 := by simp [a]
let b : S := ⟨x, h.subset_extend _ (by simp)⟩
have hb : Basis.extend h b = x := by simp [b]
by_cases e : a = b
· obtain rfl : 1 = x := congr_arg Subtype.val e
exact ⟨1, map_one _⟩
have := DFunLike.congr_fun
(DFunLike.congr_arg ((Basis.extend h).tensorProduct (Basis.extend h)).repr H) (a, b)
simp only [Basis.tensorProduct_repr_tmul_apply, ← ha, ← hb, Basis.repr_self, smul_eq_mul,
Finsupp.single_apply, e, Ne.symm e, ↓reduceIte, mul_one, mul_zero, one_ne_zero] at this
· rw [LinearIndependent.pair_iff] at h'
simp only [not_forall, not_and, exists_prop] at h'
obtain ⟨a, b, e, hab⟩ := h'
have : IsUnit b := by
rw [isUnit_iff_ne_zero]
rintro rfl
rw [zero_smul, ← algebraMap_eq_smul_one, add_zero,
(injective_iff_map_eq_zero' _).mp (algebraMap K L).injective] at e
cases hab e rfl
use (-this.unit⁻¹ * a)
rw [map_mul, ← Algebra.smul_def, algebraMap_eq_smul_one, eq_neg_iff_add_eq_zero.mpr e,
smul_neg, neg_smul, neg_neg, smul_smul, this.val_inv_mul, one_smul] | theorem | RingTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.RingTheory.Artinian.Ring",
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.Algebra.Polynomial.Taylor",
"Mathlib.RingTheory.Unramified.Finite"
] | Mathlib/RingTheory/Unramified/Field.lean | range_eq_top_of_isPurelyInseparable | null |
isSeparable : Algebra.IsSeparable K L := by
have := finite_of_free (R := K) (S := L)
rw [← separableClosure.eq_top_iff]
have := of_comp K (separableClosure K L) L
have := EssFiniteType.of_comp K (separableClosure K L) L
ext
change _ ↔ _ ∈ (⊤ : Subring _)
rw [← range_eq_top_of_isPurelyInseparable (separableClosure K L) L]
simp | theorem | RingTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.RingTheory.Artinian.Ring",
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.Algebra.Polynomial.Taylor",
"Mathlib.RingTheory.Unramified.Finite"
] | Mathlib/RingTheory/Unramified/Field.lean | isSeparable | null |
iff_isSeparable (L : Type u) [Field L] [Algebra K L] [EssFiniteType K L] :
FormallyUnramified K L ↔ Algebra.IsSeparable K L :=
⟨fun _ ↦ isSeparable K L, fun _ ↦ of_isSeparable K L⟩ | theorem | RingTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.RingTheory.Artinian.Ring",
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.Algebra.Polynomial.Taylor",
"Mathlib.RingTheory.Unramified.Finite"
] | Mathlib/RingTheory/Unramified/Field.lean | iff_isSeparable | null |
iff_exists_tensorProduct [EssFiniteType R S] :
FormallyUnramified R S ↔ ∃ t : S ⊗[R] S,
(∀ s, ((1 : S) ⊗ₜ[R] s - s ⊗ₜ[R] (1 : S)) * t = 0) ∧ TensorProduct.lmul' R t = 1 := by
rw [formallyUnramified_iff, KaehlerDifferential,
Ideal.cotangent_subsingleton_iff, Ideal.isIdempotentElem_iff_of_fg _
(KaehlerDifferential.ideal_fg R S)]
have : ∀ t : S ⊗[R] S, TensorProduct.lmul' R t = 1 ↔ 1 - t ∈ KaehlerDifferential.ideal R S := by
intro t
simp only [KaehlerDifferential.ideal, RingHom.mem_ker, map_sub, map_one,
sub_eq_zero, @eq_comm S 1]
simp_rw [this, ← KaehlerDifferential.span_range_eq_ideal]
constructor
· rintro ⟨e, he₁, he₂ : _ = Ideal.span _⟩
refine ⟨1 - e, ?_, ?_⟩
· intro s
obtain ⟨x, hx⟩ : e ∣ 1 ⊗ₜ[R] s - s ⊗ₜ[R] 1 := by
rw [← Ideal.mem_span_singleton, ← he₂]
exact Ideal.subset_span ⟨s, rfl⟩
rw [hx, mul_comm, ← mul_assoc, sub_mul, one_mul, he₁.eq, sub_self, zero_mul]
· rw [sub_sub_cancel, he₂, Ideal.mem_span_singleton]
· rintro ⟨t, ht₁, ht₂⟩
use 1 - t
rw [← sub_sub_self 1 t] at ht₁; generalize 1 - t = e at *
constructor
· suffices e ∈ (Submodule.span (S ⊗[R] S) {1 - e}).annihilator by
simpa [IsIdempotentElem, mul_sub, sub_eq_zero, eq_comm, -Ideal.submodule_span_eq,
Submodule.mem_annihilator_span_singleton] using this
exact (show Ideal.span _ ≤ _ by simpa only [Ideal.span_le, Set.range_subset_iff,
Submodule.mem_annihilator_span_singleton, SetLike.mem_coe]) ht₂
· apply le_antisymm <;> simp only [Ideal.submodule_span_eq, Ideal.mem_span_singleton, ht₂,
Ideal.span_le, Set.singleton_subset_iff, SetLike.mem_coe, Set.range_subset_iff]
intro s
use 1 ⊗ₜ[R] s - s ⊗ₜ[R] 1
linear_combination ht₁ s | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IdempotentFG",
"Mathlib.RingTheory.Unramified.Basic",
"Mathlib.RingTheory.Flat.Stability"
] | Mathlib/RingTheory/Unramified/Finite.lean | iff_exists_tensorProduct | Proposition I.2.3 + I.2.6 of [iversen]
A finite-type `R`-algebra `S` is (formally) unramified iff there exists a `t : S ⊗[R] S` satisfying
1. `t` annihilates every `1 ⊗ s - s ⊗ 1`.
2. the image of `t` is `1` under the map `S ⊗[R] S → S`. |
finite_of_free_aux (I) [DecidableEq I] (b : Basis I R S)
(f : I →₀ S) (x : S) (a : I → I →₀ R) (ha : a = fun i ↦ b.repr (b i * x)) :
(1 ⊗ₜ[R] x * Finsupp.sum f fun i y ↦ y ⊗ₜ[R] b i) =
Finset.sum (f.support.biUnion fun i ↦ (a i).support) fun k ↦
Finsupp.sum (b.repr (f.sum fun i y ↦ a i k • y)) fun j c ↦ c • b j ⊗ₜ[R] b k := by
rw [Finsupp.sum, Finset.mul_sum]
subst ha
let a i := b.repr (b i * x)
conv_lhs =>
simp only [TensorProduct.tmul_mul_tmul, one_mul, mul_comm x (b _),
← show ∀ i, Finsupp.linearCombination _ b (a i) = b i * x from
fun _ ↦ b.linearCombination_repr _]
conv_lhs => simp only [Finsupp.linearCombination, Finsupp.coe_lsum,
LinearMap.coe_smulRight, LinearMap.id_coe, id_eq, Finsupp.sum, TensorProduct.tmul_sum,
← TensorProduct.smul_tmul]
have h₁ : ∀ k,
(Finsupp.sum (Finsupp.sum f fun i y ↦ a i k • b.repr y) fun j z ↦ z • b j ⊗ₜ[R] b k) =
(f.sum fun i y ↦ (b.repr y).sum fun j z ↦ a i k • z • b j ⊗ₜ[R] b k) := by
intro i
rw [Finsupp.sum_sum_index]
congr
ext j s
rw [Finsupp.sum_smul_index]
simp only [mul_smul, Finsupp.sum, ← Finset.smul_sum]
· intro; simp only [zero_smul]
· intro; simp only [zero_smul]
· intros; simp only [add_smul]
have h₂ : ∀ (x : S), ((b.repr x).support.sum fun a ↦ b.repr x a • b a) = x := by
simpa only [Finsupp.linearCombination_apply, Finsupp.sum] using b.linearCombination_repr
simp only [a] at h₁
simp_rw [map_finsuppSum, map_smul, h₁, Finsupp.sum, Finset.sum_comm (t := f.support),
TensorProduct.smul_tmul', ← TensorProduct.sum_tmul, ← Finset.smul_sum, h₂]
apply Finset.sum_congr rfl
intro i hi
apply Finset.sum_subset_zero_on_sdiff
· exact Finset.subset_biUnion_of_mem (fun i ↦ (a i).support) hi
· simp only [a, Finset.mem_sdiff, Finset.mem_biUnion, Finsupp.mem_support_iff, ne_eq, not_not,
and_imp, forall_exists_index]
simp +contextual
· exact fun _ _ ↦ rfl
variable [FormallyUnramified R S] [EssFiniteType R S]
variable (R S) in | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.IdempotentFG",
"Mathlib.RingTheory.Unramified.Basic",
"Mathlib.RingTheory.Flat.Stability"
] | Mathlib/RingTheory/Unramified/Finite.lean | finite_of_free_aux | null |
noncomputable
elem : S ⊗[R] S :=
(iff_exists_tensorProduct.mp inferInstance).choose | def | RingTheory | [
"Mathlib.RingTheory.Ideal.IdempotentFG",
"Mathlib.RingTheory.Unramified.Basic",
"Mathlib.RingTheory.Flat.Stability"
] | Mathlib/RingTheory/Unramified/Finite.lean | elem | A finite-type `R`-algebra `S` is (formally) unramified iff there exists a `t : S ⊗[R] S` satisfying
1. `t` annihilates every `1 ⊗ s - s ⊗ 1`.
2. the image of `t` is `1` under the map `S ⊗[R] S → S`.
See `Algebra.FormallyUnramified.iff_exists_tensorProduct`.
This is the choice of such a `t`. |
one_tmul_sub_tmul_one_mul_elem
(s : S) : (1 ⊗ₜ s - s ⊗ₜ 1) * elem R S = 0 :=
(iff_exists_tensorProduct.mp inferInstance).choose_spec.1 s | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.IdempotentFG",
"Mathlib.RingTheory.Unramified.Basic",
"Mathlib.RingTheory.Flat.Stability"
] | Mathlib/RingTheory/Unramified/Finite.lean | one_tmul_sub_tmul_one_mul_elem | null |
one_tmul_mul_elem
(s : S) : (1 ⊗ₜ s) * elem R S = (s ⊗ₜ 1) * elem R S := by
rw [← sub_eq_zero, ← sub_mul, one_tmul_sub_tmul_one_mul_elem] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.IdempotentFG",
"Mathlib.RingTheory.Unramified.Basic",
"Mathlib.RingTheory.Flat.Stability"
] | Mathlib/RingTheory/Unramified/Finite.lean | one_tmul_mul_elem | null |
lmul_elem :
TensorProduct.lmul' R (elem R S) = 1 :=
(iff_exists_tensorProduct.mp inferInstance).choose_spec.2
variable (R S) | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.IdempotentFG",
"Mathlib.RingTheory.Unramified.Basic",
"Mathlib.RingTheory.Flat.Stability"
] | Mathlib/RingTheory/Unramified/Finite.lean | lmul_elem | null |
finite_of_free [Module.Free R S] : Module.Finite R S := by
classical
let I := Module.Free.ChooseBasisIndex R S
let b : Basis I R S := Module.Free.chooseBasis R S
have ⟨f, hf⟩ : ∃ (a : I →₀ S), elem R S = a.sum (fun i x ↦ x ⊗ₜ b i) := by
let b' := ((Basis.singleton PUnit.{1} S).tensorProduct b).reindex (Equiv.punitProd I)
use b'.repr (elem R S)
conv_lhs => rw [← b'.linearCombination_repr (elem R S), Finsupp.linearCombination_apply]
congr! with _ i x
simp [b', Basis.tensorProduct, TensorProduct.smul_tmul']
constructor
use Finset.image₂ (fun i j ↦ f i * b j) f.support f.support
rw [← top_le_iff]
rintro x -
let a : I → I →₀ R := fun i ↦ b.repr (b i * x)
let F : I →₀ I →₀ R := Finsupp.onFinset f.support (fun j ↦ b.repr (x * f j))
(fun j ↦ not_imp_comm.mp fun hj ↦ by simp [Finsupp.notMem_support_iff.mp hj])
have hG : ∀ j ∉ (Finset.biUnion f.support fun i ↦ (a i).support),
b.repr (f.sum (fun i y ↦ a i j • y)) = 0 := by
intro j hj
simp only [Finset.mem_biUnion, Finsupp.mem_support_iff, ne_eq, not_exists, not_and,
not_not] at hj
simp only [Finsupp.sum]
trans b.repr (f.support.sum (fun _ ↦ 0))
· refine congr_arg b.repr (Finset.sum_congr rfl ?_)
simp only [Finsupp.mem_support_iff]
intro i hi
rw [hj i hi, zero_smul]
· simp only [Finset.sum_const_zero, map_zero]
let G : I →₀ I →₀ R := Finsupp.onFinset (Finset.biUnion f.support (fun i ↦ (a i).support))
(fun j ↦ b.repr (f.sum (fun i y ↦ a i j • y)))
(fun j ↦ not_imp_comm.mp (hG j))
have : F = G := by
apply Finsupp.finsuppProdEquiv.symm.injective
apply (Finsupp.equivCongrLeft (Equiv.prodComm I I)).injective
apply (b.tensorProduct b).repr.symm.injective
suffices (F.sum fun a f ↦ f.sum fun b' c ↦ c • b b' ⊗ₜ[R] b a) =
G.sum fun a f ↦ f.sum fun b' c ↦ c • b b' ⊗ₜ[R] b a by
simpa [Finsupp.linearCombination_apply, Finsupp.sum_uncurry_index]
rw [Finsupp.onFinset_sum, Finsupp.onFinset_sum]
have : ∀ i, ((b.repr (x * f i)).sum fun j k ↦ k • b j ⊗ₜ[R] b i) = (x * f i) ⊗ₜ[R] b i := by
intro i
simp_rw [Finsupp.sum, TensorProduct.smul_tmul', ← TensorProduct.sum_tmul]
congr 1
exact b.linearCombination_repr _
trans (x ⊗ₜ 1) * elem R S
· simp_rw [this, hf, Finsupp.sum, Finset.mul_sum, TensorProduct.tmul_mul_tmul, one_mul]
· rw [← one_tmul_mul_elem, hf, finite_of_free_aux]
rfl
· intro; simp
· intro; simp
... | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.IdempotentFG",
"Mathlib.RingTheory.Unramified.Basic",
"Mathlib.RingTheory.Flat.Stability"
] | Mathlib/RingTheory/Unramified/Finite.lean | finite_of_free | An unramified free algebra is finitely generated. Iversen I.2.8 |
noncomputable
sec :
M →ₗ[S] S ⊗[R] M where
__ := ((TensorProduct.AlgebraTensorModule.mapBilinear R S S S S S M
LinearMap.id).flip (elem R S)).comp (lsmul R R M).toLinearMap.flip
map_smul' r m := by
simp only [AddHom.toFun_eq_coe, LinearMap.coe_toAddHom, LinearMap.coe_comp, Function.comp_apply,
LinearMap.flip_apply, TensorProduct.AlgebraTensorModule.mapBilinear_apply, RingHom.id_apply]
trans (TensorProduct.AlgebraTensorModule.map (LinearMap.id (R := S) (M := S))
((LinearMap.flip (AlgHom.toLinearMap (lsmul R R M))) m)) ((1 ⊗ₜ r) * elem R S)
· induction elem R S using TensorProduct.induction_on
· simp
· simp [smul_comm r]
· simp only [map_add, mul_add, *]
· have := one_tmul_sub_tmul_one_mul_elem (R := R) r
rw [sub_mul, sub_eq_zero] at this
rw [this]
induction elem R S using TensorProduct.induction_on
· simp
· simp [TensorProduct.smul_tmul']
· simp only [map_add, smul_add, mul_add, *] | def | RingTheory | [
"Mathlib.RingTheory.Ideal.IdempotentFG",
"Mathlib.RingTheory.Unramified.Basic",
"Mathlib.RingTheory.Flat.Stability"
] | Mathlib/RingTheory/Unramified/Finite.lean | sec | Proposition I.2.3 of [iversen]
If `S` is an unramified `R`-algebra, and `M` is a `S`-module, then the map
`S ⊗[R] M →ₗ[S] M` taking `(b, m) ↦ b • m` admits a `S`-linear section. |
comp_sec :
(TensorProduct.AlgebraTensorModule.lift
((lsmul S S M).toLinearMap.flip.restrictScalars R).flip).comp (sec R S M) =
LinearMap.id := by
ext x
simp only [sec, LinearMap.coe_comp, LinearMap.coe_mk, LinearMap.coe_toAddHom,
Function.comp_apply, LinearMap.flip_apply, TensorProduct.AlgebraTensorModule.mapBilinear_apply,
TensorProduct.AlgebraTensorModule.lift_apply, LinearMap.id_coe, id_eq]
trans (TensorProduct.lmul' R (elem R S)) • x
· induction elem R S using TensorProduct.induction_on with
| zero => simp
| tmul r s => simp [mul_smul, smul_comm r s]
| add y z hy hz => simp [hy, hz, add_smul]
· rw [lmul_elem, one_smul] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.IdempotentFG",
"Mathlib.RingTheory.Unramified.Basic",
"Mathlib.RingTheory.Flat.Stability"
] | Mathlib/RingTheory/Unramified/Finite.lean | comp_sec | null |
flat_of_restrictScalars [Module.Flat R M] : Module.Flat S M :=
Module.Flat.of_retract _ _ (comp_sec R S M) | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.IdempotentFG",
"Mathlib.RingTheory.Unramified.Basic",
"Mathlib.RingTheory.Flat.Stability"
] | Mathlib/RingTheory/Unramified/Finite.lean | flat_of_restrictScalars | If `S` is an unramified `R`-algebra, then `R`-flat implies `S`-flat. Iversen I.2.7 |
projective_of_restrictScalars [Module.Projective R M] : Module.Projective S M :=
Module.Projective.of_split _ _ (comp_sec R S M) | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.IdempotentFG",
"Mathlib.RingTheory.Unramified.Basic",
"Mathlib.RingTheory.Flat.Stability"
] | Mathlib/RingTheory/Unramified/Finite.lean | projective_of_restrictScalars | If `S` is an unramified `R`-algebra, then `R`-projective implies `S`-projective. |
FormallyUnramified.isField_quotient_map_maximalIdeal [FormallyUnramified R S] :
IsField (S ⧸ (maximalIdeal R).map (algebraMap R S)) := by
let mR := (maximalIdeal R).map (algebraMap R S)
have hmR : mR ≤ maximalIdeal S := ((local_hom_TFAE (algebraMap R S)).out 0 2 rfl rfl).mp ‹_›
letI : Algebra (ResidueField R) (S ⧸ mR) := inferInstanceAs (Algebra (R ⧸ _) _)
have : IsScalarTower R (ResidueField R) (S ⧸ mR) := inferInstanceAs (IsScalarTower R (R ⧸ _) _)
have : FormallyUnramified (ResidueField R) (S ⧸ mR) := .of_comp R _ _
have : EssFiniteType (ResidueField R) (S ⧸ mR) := .of_comp R _ _
have : Module.Finite (ResidueField R) (S ⧸ mR) := FormallyUnramified.finite_of_free _ _
have : IsReduced (S ⧸ mR) := FormallyUnramified.isReduced_of_field (ResidueField R) (S ⧸ mR)
have : IsArtinianRing (S ⧸ mR) := isArtinian_of_tower (ResidueField R) inferInstance
have : Nontrivial (S ⧸ mR) := Ideal.Quotient.nontrivial fun e ↦
(maximalIdeal.isMaximal S).ne_top (top_le_iff.mp <| e.symm.trans_le hmR)
have : IsLocalRing (S ⧸ mR) := .of_surjective' _ Ideal.Quotient.mk_surjective
have : maximalIdeal (S ⧸ mR) = ⊥ := by
rw [← jacobson_eq_maximalIdeal _ bot_ne_top, IsArtinianRing.jacobson_eq_radical,
← Ideal.zero_eq_bot, ← nilradical, nilradical_eq_zero]
rwa [← isField_iff_maximalIdeal_eq] at this
@[stacks 00UW "(1)"] | lemma | RingTheory | [
"Mathlib.RingTheory.LocalRing.Module",
"Mathlib.RingTheory.LocalRing.ResidueField.Ideal",
"Mathlib.RingTheory.Unramified.Field",
"Mathlib.RingTheory.Unramified.Locus"
] | Mathlib/RingTheory/Unramified/LocalRing.lean | FormallyUnramified.isField_quotient_map_maximalIdeal | null |
FormallyUnramified.map_maximalIdeal [FormallyUnramified R S] :
(maximalIdeal R).map (algebraMap R S) = maximalIdeal S := by
apply eq_maximalIdeal
rw [Ideal.Quotient.maximal_ideal_iff_isField_quotient]
exact isField_quotient_map_maximalIdeal
@[stacks 02FM] | lemma | RingTheory | [
"Mathlib.RingTheory.LocalRing.Module",
"Mathlib.RingTheory.LocalRing.ResidueField.Ideal",
"Mathlib.RingTheory.Unramified.Field",
"Mathlib.RingTheory.Unramified.Locus"
] | Mathlib/RingTheory/Unramified/LocalRing.lean | FormallyUnramified.map_maximalIdeal | null |
FormallyUnramified.of_map_maximalIdeal
[Algebra.IsSeparable (ResidueField R) (ResidueField S)]
(H : (maximalIdeal R).map (algebraMap R S) = maximalIdeal S) :
Algebra.FormallyUnramified R S := by
constructor
have : FormallyUnramified (ResidueField R) (ResidueField S) := .of_isSeparable _ _
have : FormallyUnramified R (ResidueField S) := .comp _ (ResidueField R) _
rw [← subsingleton_tensorProduct (R := S)]
refine subsingleton_of_forall_eq 0 fun x ↦ ?_
obtain ⟨x, rfl⟩ := (KaehlerDifferential.exact_kerCotangentToTensor_mapBaseChange R S
(ResidueField S) Ideal.Quotient.mk_surjective x).mp (Subsingleton.elim _ _)
obtain ⟨⟨x, hx⟩, rfl⟩ := Ideal.toCotangent_surjective _ x
simp only [KaehlerDifferential.kerCotangentToTensor_toCotangent]
replace hx : x ∈ Ideal.map (algebraMap R S) (maximalIdeal R) := by simpa [H] using hx
induction hx using Submodule.span_induction with
| zero => simp
| mem x h => obtain ⟨x, hx, rfl⟩ := h; simp
| add x y hx hy _ _ => simp [*, TensorProduct.tmul_add]
| smul a x hx _ =>
have : residue S x = 0 := by rwa [residue_eq_zero_iff, ← H]
simp [*, TensorProduct.tmul_add, TensorProduct.smul_tmul', ← Algebra.algebraMap_eq_smul_one] | lemma | RingTheory | [
"Mathlib.RingTheory.LocalRing.Module",
"Mathlib.RingTheory.LocalRing.ResidueField.Ideal",
"Mathlib.RingTheory.Unramified.Field",
"Mathlib.RingTheory.Unramified.Locus"
] | Mathlib/RingTheory/Unramified/LocalRing.lean | FormallyUnramified.of_map_maximalIdeal | null |
FormallyUnramified.iff_map_maximalIdeal_eq :
Algebra.FormallyUnramified R S ↔
Algebra.IsSeparable (ResidueField R) (ResidueField S) ∧
(maximalIdeal R).map (algebraMap R S) = maximalIdeal S :=
⟨fun _ ↦ ⟨inferInstance, map_maximalIdeal⟩, fun ⟨_, e⟩ ↦ of_map_maximalIdeal e⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.LocalRing.Module",
"Mathlib.RingTheory.LocalRing.ResidueField.Ideal",
"Mathlib.RingTheory.Unramified.Field",
"Mathlib.RingTheory.Unramified.Locus"
] | Mathlib/RingTheory/Unramified/LocalRing.lean | FormallyUnramified.iff_map_maximalIdeal_eq | null |
isUnramifiedAt_iff_map_eq [EssFiniteType R S]
(p : Ideal R) [p.IsPrime] (q : Ideal S) [q.IsPrime] [q.LiesOver p] :
Algebra.IsUnramifiedAt R q ↔
Algebra.IsSeparable p.ResidueField q.ResidueField ∧
p.map (algebraMap R (Localization.AtPrime q)) = maximalIdeal _ := by
letI : Algebra (Localization.AtPrime p) (Localization.AtPrime q) :=
(Localization.localRingHom p q (algebraMap R S) Ideal.LiesOver.over).toAlgebra
have : IsScalarTower R (Localization.AtPrime p) (Localization.AtPrime q) := .of_algebraMap_eq
fun x ↦ (Localization.localRingHom_to_map p q (algebraMap R S) Ideal.LiesOver.over x).symm
letI : IsLocalHom (algebraMap (Localization.AtPrime p) (Localization.AtPrime q)) :=
Localization.isLocalHom_localRingHom _ _ _ Ideal.LiesOver.over
have : EssFiniteType (Localization.AtPrime p) (Localization.AtPrime q) := .of_comp R _ _
trans Algebra.FormallyUnramified (Localization.AtPrime p) (Localization.AtPrime q)
· exact ⟨fun _ ↦ .of_comp R _ _,
fun _ ↦ Algebra.FormallyUnramified.comp _ (Localization.AtPrime p) _⟩
rw [FormallyUnramified.iff_map_maximalIdeal_eq]
congr!
rw [RingHom.algebraMap_toAlgebra, ← Localization.AtPrime.map_eq_maximalIdeal,
Ideal.map_map, Localization.localRingHom,
IsLocalization.map_comp, ← IsScalarTower.algebraMap_eq] | lemma | RingTheory | [
"Mathlib.RingTheory.LocalRing.Module",
"Mathlib.RingTheory.LocalRing.ResidueField.Ideal",
"Mathlib.RingTheory.Unramified.Field",
"Mathlib.RingTheory.Unramified.Locus"
] | Mathlib/RingTheory/Unramified/LocalRing.lean | isUnramifiedAt_iff_map_eq | Let `A` be an essentially of finite type `R`-algebra, `q` be a prime over `p`.
Then `A` is unramified at `p` if and only if `κ(q)/κ(p)` is separable, and `pS_q = qS_q`. |
IsUnramifiedAt (q : Ideal A) [q.IsPrime] : Prop :=
FormallyUnramified R (Localization.AtPrime q)
variable (R A) in | abbrev | RingTheory | [
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.RingTheory.Etale.Kaehler",
"Mathlib.RingTheory.Support"
] | Mathlib/RingTheory/Unramified/Locus.lean | IsUnramifiedAt | We say that an `R`-algebra `A` is unramified at a prime `q` of `A`
if `A_q` is formally unramified over `R`.
If `A` is of finite type over `R` and `q` is lying over `p`, then this is equivalent to
`κ(q)/κ(p)` being separable and `pA_q = qA_q`.
See `Algebra.isUnramifiedAt_iff_map_eq` in `RingTheory.Unramified.LocalRing` |
unramifiedLocus : Set (PrimeSpectrum A) :=
{ p | IsUnramifiedAt R p.asIdeal } | def | RingTheory | [
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.RingTheory.Etale.Kaehler",
"Mathlib.RingTheory.Support"
] | Mathlib/RingTheory/Unramified/Locus.lean | unramifiedLocus | `Algebra.unramifiedLocus R A` is the set of primes `p` of `A` that are unramified. |
IsUnramifiedAt.comp
(p : Ideal A) (P : Ideal B) [P.LiesOver p] [p.IsPrime] [P.IsPrime]
[IsUnramifiedAt R p] [IsUnramifiedAt A P] : IsUnramifiedAt R P := by
have : FormallyUnramified (Localization.AtPrime p) (Localization.AtPrime P) :=
.of_comp A _ _
exact FormallyUnramified.comp R (Localization.AtPrime p) _
variable (R) in | lemma | RingTheory | [
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.RingTheory.Etale.Kaehler",
"Mathlib.RingTheory.Support"
] | Mathlib/RingTheory/Unramified/Locus.lean | IsUnramifiedAt.comp | null |
IsUnramifiedAt.of_restrictScalars (P : Ideal B) [P.IsPrime]
[IsUnramifiedAt R P] : IsUnramifiedAt A P :=
FormallyUnramified.of_comp R _ _ | lemma | RingTheory | [
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.RingTheory.Etale.Kaehler",
"Mathlib.RingTheory.Support"
] | Mathlib/RingTheory/Unramified/Locus.lean | IsUnramifiedAt.of_restrictScalars | null |
unramifiedLocus_eq_compl_support :
unramifiedLocus R A = (Module.support A Ω[A⁄R])ᶜ := by
ext p
simp only [Set.mem_compl_iff, Module.notMem_support_iff]
have := IsLocalizedModule.iso p.asIdeal.primeCompl
(KaehlerDifferential.map R R A (Localization.AtPrime p.asIdeal))
exact (Algebra.formallyUnramified_iff _ _).trans this.subsingleton_congr.symm | lemma | RingTheory | [
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.RingTheory.Etale.Kaehler",
"Mathlib.RingTheory.Support"
] | Mathlib/RingTheory/Unramified/Locus.lean | unramifiedLocus_eq_compl_support | null |
basicOpen_subset_unramifiedLocus_iff {f : A} :
↑(PrimeSpectrum.basicOpen f) ⊆ unramifiedLocus R A ↔
Algebra.FormallyUnramified R (Localization.Away f) := by
rw [unramifiedLocus_eq_compl_support, Set.subset_compl_comm,
PrimeSpectrum.basicOpen_eq_zeroLocus_compl, compl_compl,
← LocalizedModule.subsingleton_iff_support_subset, Algebra.formallyUnramified_iff]
exact (IsLocalizedModule.iso (.powers f)
(KaehlerDifferential.map R R A (Localization.Away f))).subsingleton_congr | lemma | RingTheory | [
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.RingTheory.Etale.Kaehler",
"Mathlib.RingTheory.Support"
] | Mathlib/RingTheory/Unramified/Locus.lean | basicOpen_subset_unramifiedLocus_iff | null |
unramifiedLocus_eq_univ_iff :
unramifiedLocus R A = Set.univ ↔ Algebra.FormallyUnramified R A := by
rw [unramifiedLocus_eq_compl_support, compl_eq_comm, Set.compl_univ, eq_comm,
Module.support_eq_empty_iff, Algebra.formallyUnramified_iff] | lemma | RingTheory | [
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.RingTheory.Etale.Kaehler",
"Mathlib.RingTheory.Support"
] | Mathlib/RingTheory/Unramified/Locus.lean | unramifiedLocus_eq_univ_iff | null |
isOpen_unramifiedLocus [EssFiniteType R A] : IsOpen (unramifiedLocus R A) := by
rw [unramifiedLocus_eq_compl_support, Module.support_eq_zeroLocus]
exact (PrimeSpectrum.isClosed_zeroLocus _).isOpen_compl | lemma | RingTheory | [
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.RingTheory.Etale.Kaehler",
"Mathlib.RingTheory.Support"
] | Mathlib/RingTheory/Unramified/Locus.lean | isOpen_unramifiedLocus | null |
pi_iff :
FormallyUnramified R (∀ i, f i) ↔ ∀ i, FormallyUnramified R (f i) := by
classical
cases nonempty_fintype I
constructor
· intro _ i
exact FormallyUnramified.of_surjective (Pi.evalAlgHom R f i) (Function.surjective_eval i)
· intro H
rw [iff_comp_injective]
intro B _ _ J hJ f₁ f₂ e
ext g
rw [← Finset.univ_sum_single g, map_sum, map_sum]
refine Finset.sum_congr rfl ?_
rintro x -
have hf : ∀ x, f₁ x - f₂ x ∈ J := by
intro g
rw [← Ideal.Quotient.eq_zero_iff_mem, map_sub, sub_eq_zero]
exact AlgHom.congr_fun e g
let e : ∀ i, f i := Pi.single x 1
have he : IsIdempotentElem e := by simp [IsIdempotentElem, e, ← Pi.single_mul]
have h₁ : (f₁ e) * (1 - f₂ e) = 0 := by
rw [← Ideal.mem_bot, ← hJ, ← ((he.map f₁).mul (he.map f₂).one_sub).eq, ← pow_two]
apply Ideal.pow_mem_pow
convert Ideal.mul_mem_left _ (f₁ e) (hf e) using 1
rw [mul_sub, mul_sub, mul_one, (he.map f₁).eq]
have h₂ : (f₂ e) * (1 - f₁ e) = 0 := by
rw [← Ideal.mem_bot, ← hJ, ← ((he.map f₂).mul (he.map f₁).one_sub).eq, ← pow_two]
apply Ideal.pow_mem_pow
convert Ideal.mul_mem_left _ (-f₂ e) (hf e) using 1
rw [neg_mul, mul_sub, mul_sub, mul_one, neg_sub, (he.map f₂).eq]
have H : f₁ e = f₂ e := by
trans f₁ e * f₂ e
· rw [← sub_eq_zero, ← h₁, mul_sub, mul_one]
· rw [eq_comm, ← sub_eq_zero, ← h₂, mul_sub, mul_one, mul_comm]
let J' := Ideal.span {1 - f₁ e}
let f₁' : f x →ₐ[R] B ⧸ J' := by
apply AlgHom.ofLinearMap
(((Ideal.Quotient.mkₐ R J').comp f₁).toLinearMap.comp (LinearMap.single _ _ x))
· simp only [AlgHom.comp_toLinearMap, LinearMap.coe_comp, LinearMap.coe_single,
Function.comp_apply, AlgHom.toLinearMap_apply, Ideal.Quotient.mkₐ_eq_mk]
rw [eq_comm, ← sub_eq_zero, ← (Ideal.Quotient.mk J').map_one, ← map_sub,
Ideal.Quotient.eq_zero_iff_mem, Ideal.mem_span_singleton]
· intro r s; simp [Pi.single_mul]
let f₂' : f x →ₐ[R] B ⧸ J' := by
apply AlgHom.ofLinearMap
(((Ideal.Quotient.mkₐ R J').comp f₂).toLinearMap.comp (LinearMap.single _ _ x))
· simp only [AlgHom.comp_toLinearMap, LinearMap.coe_comp, LinearMap.coe_single,
Function.comp_apply, AlgHom.toLinearMap_apply, Ideal.Quotient.mkₐ_eq_mk]
rw [eq_comm, ← sub_eq_zero, ← (Ideal.Quotient.mk J').map_one, ← map_sub,
Ideal.Quotient.eq_zero_iff_mem, Ideal.mem_span_singleton, H]
· intro r s; simp [Pi.single_mul]
... | theorem | RingTheory | [
"Mathlib.RingTheory.Unramified.Basic"
] | Mathlib/RingTheory/Unramified/Pi.lean | pi_iff | null |
algebraMap_injective : Injective (algebraMap v.valuationSubring L) :=
(FaithfulSMul.algebraMap_injective K L).comp (IsFractionRing.injective _ _) | theorem | RingTheory | [
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/AlgebraInstances.lean | algebraMap_injective | null |
isIntegral_of_mem_ringOfIntegers {x : L} (hx : x ∈ integralClosure v.valuationSubring L) :
IsIntegral v.valuationSubring (⟨x, hx⟩ : integralClosure v.valuationSubring L) := by
obtain ⟨P, hPm, hP⟩ := hx
refine ⟨P, hPm, ?_⟩
rw [← Polynomial.aeval_def, ← Subalgebra.coe_eq_zero, Polynomial.aeval_subalgebra_coe,
Polynomial.aeval_def, Subtype.coe_mk, hP] | theorem | RingTheory | [
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/AlgebraInstances.lean | isIntegral_of_mem_ringOfIntegers | null |
isIntegral_of_mem_ringOfIntegers' {x : (integralClosure v.valuationSubring L)} :
IsIntegral v.valuationSubring (x : integralClosure v.valuationSubring L) := by
apply isIntegral_of_mem_ringOfIntegers
variable (E : Type _) [Field E] [Algebra K E] [Algebra L E] [IsScalarTower K L E] | theorem | RingTheory | [
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/AlgebraInstances.lean | isIntegral_of_mem_ringOfIntegers' | null |
algebra :
Algebra (integralClosure v.valuationSubring L) (integralClosure v.valuationSubring E) :=
RingHom.toAlgebra
{ toFun := fun k => ⟨algebraMap L E k, IsIntegral.algebraMap k.2⟩
map_zero' :=
Subtype.ext <| by simp only [Subalgebra.coe_zero, map_zero]
map_one' := Subtype.ext <| by simp only [Subalgebra.coe_one, map_one]
map_add' := fun x y =>
Subtype.ext <| by simp only [map_add, Subalgebra.coe_add]
map_mul' := fun x y =>
Subtype.ext <| by simp only [Subalgebra.coe_mul, map_mul] } | instance | RingTheory | [
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/AlgebraInstances.lean | algebra | Given an algebra between two field extensions `L` and `E` of a field `K` with a valuation `v`,
create an algebra between their two rings of integers. |
protected noncomputable equiv (R : Type*) [CommRing R] [Algebra v.valuationSubring R]
[Algebra R L] [IsScalarTower v.valuationSubring R L]
[IsIntegralClosure R v.valuationSubring L] : integralClosure v.valuationSubring L ≃+* R := by
have := IsScalarTower.subalgebra' (valuationSubring v) L L
(integralClosure (valuationSubring v) L)
exact (IsIntegralClosure.equiv v.valuationSubring R L
(integralClosure v.valuationSubring L)).symm.toRingEquiv | def | RingTheory | [
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/AlgebraInstances.lean | equiv | A ring equivalence between the integral closure of the valuation subring of `K` in `L`
and a ring `R` satisfying `isIntegralClosure R v.valuationSubring L`. |
integralClosure_algebraMap_injective :
Injective (algebraMap v.valuationSubring (integralClosure v.valuationSubring L)) :=
FaithfulSMul.algebraMap_injective ↥v.valuationSubring ↥(integralClosure (↥v.valuationSubring) L) | theorem | RingTheory | [
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/AlgebraInstances.lean | integralClosure_algebraMap_injective | null |
MonoidWithZeroHom.instLinearOrderedCommGroupWithZeroMrange (v : F →*₀ Γ₀) :
LinearOrderedCommGroupWithZero (MonoidHom.mrange v) where
__ : CommGroupWithZero (MonoidHom.mrange v) := inferInstance
__ : LinearOrder (MonoidHom.mrange v) := inferInstance
bot := ⟨⊥, by simp [bot_eq_zero'']⟩
bot_le a := by simp [bot_eq_zero'', ← Subtype.coe_le_coe]
zero_le_one := Subtype.coe_le_coe.mp zero_le_one
mul_le_mul_left := by
simp only [Subtype.forall, MonoidHom.mem_mrange, forall_exists_index, Submonoid.mk_mul_mk,
Subtype.mk_le_mk, forall_apply_eq_imp_iff]
intro a b hab c
exact mul_le_mul_left' hab (v c) | instance | RingTheory | [
"Mathlib.GroupTheory.ArchimedeanDensely",
"Mathlib.RingTheory.Valuation.ValuationRing"
] | Mathlib/RingTheory/Valuation/Archimedean.lean | MonoidWithZeroHom.instLinearOrderedCommGroupWithZeroMrange | null |
Valuation.instLinearOrderedCommGroupWithZeroMrange :
LinearOrderedCommGroupWithZero (MonoidHom.mrange v) :=
inferInstanceAs (LinearOrderedCommGroupWithZero (MonoidHom.mrange (v : F →*₀ Γ₀))) | instance | RingTheory | [
"Mathlib.GroupTheory.ArchimedeanDensely",
"Mathlib.RingTheory.Valuation.ValuationRing"
] | Mathlib/RingTheory/Valuation/Archimedean.lean | Valuation.instLinearOrderedCommGroupWithZeroMrange | null |
wfDvdMonoid_iff_wellFounded_gt_on_v (hv : Integers v O) :
WfDvdMonoid O ↔ WellFounded ((· > ·) on (v ∘ algebraMap O F)) := by
refine ⟨fun _ ↦ wellFounded_dvdNotUnit.mono ?_, fun h ↦ ⟨h.mono ?_⟩⟩ <;>
simp [Function.onFun, hv.dvdNotUnit_iff_lt]
open scoped Function WithZero in | lemma | RingTheory | [
"Mathlib.GroupTheory.ArchimedeanDensely",
"Mathlib.RingTheory.Valuation.ValuationRing"
] | Mathlib/RingTheory/Valuation/Archimedean.lean | wfDvdMonoid_iff_wellFounded_gt_on_v | null |
wellFounded_gt_on_v_iff_discrete_mrange [Nontrivial (MonoidHom.mrange v)ˣ]
(hv : Integers v O) :
WellFounded ((· > ·) on (v ∘ algebraMap O F)) ↔
Nonempty (MonoidHom.mrange v ≃*o ℤᵐ⁰) := by
rw [← LinearOrderedCommGroupWithZero.wellFoundedOn_setOf_ge_gt_iff_nonempty_discrete_of_ne_zero
one_ne_zero, ← Set.wellFoundedOn_range]
classical
refine ⟨fun h ↦ (h.mapsTo Subtype.val ?_).mono' (by simp), fun h ↦ (h.mapsTo ?_ ?_).mono' ?_⟩
· rintro ⟨_, x, rfl⟩
simp only [← Subtype.coe_le_coe, OneMemClass.coe_one, Set.mem_setOf_eq, Set.mem_range,
Function.comp_apply]
intro hx
obtain ⟨y, rfl⟩ := hv.exists_of_le_one hx
exact ⟨y, by simp⟩
· exact fun x ↦ if hx : x ∈ MonoidHom.mrange v then ⟨x, hx⟩ else 1
· intro
simp only [Set.mem_range, Function.comp_apply, MonoidHom.mem_mrange, Set.mem_setOf_eq,
forall_exists_index]
rintro x rfl
simp [← Subtype.coe_le_coe, hv.map_le_one]
· simp [Function.onFun] | lemma | RingTheory | [
"Mathlib.GroupTheory.ArchimedeanDensely",
"Mathlib.RingTheory.Valuation.ValuationRing"
] | Mathlib/RingTheory/Valuation/Archimedean.lean | wellFounded_gt_on_v_iff_discrete_mrange | null |
isPrincipalIdealRing_iff_not_denselyOrdered [MulArchimedean (MonoidHom.mrange v)]
(hv : Integers v O) :
IsPrincipalIdealRing O ↔ ¬ DenselyOrdered (Set.range v) := by
refine ⟨fun _ ↦ not_denselyOrdered_of_isPrincipalIdealRing hv, fun H ↦ ?_⟩
rcases subsingleton_or_nontrivial (MonoidHom.mrange v)ˣ with hs|_
· have := bijective_algebraMap_of_subsingleton_units_mrange hv
exact .of_surjective _ (RingEquiv.ofBijective _ this).symm.surjective
have : IsDomain O := hv.hom_inj.isDomain
have : ValuationRing O := ValuationRing.of_integers v hv
have : IsBezout O := ValuationRing.instIsBezout
have := ((IsBezout.TFAE (R := O)).out 1 3)
rw [this, hv.wfDvdMonoid_iff_wellFounded_gt_on_v, hv.wellFounded_gt_on_v_iff_discrete_mrange,
LinearOrderedCommGroupWithZero.discrete_iff_not_denselyOrdered]
exact H | lemma | RingTheory | [
"Mathlib.GroupTheory.ArchimedeanDensely",
"Mathlib.RingTheory.Valuation.ValuationRing"
] | Mathlib/RingTheory/Valuation/Archimedean.lean | isPrincipalIdealRing_iff_not_denselyOrdered | null |
isPrincipalIdealRing_iff_not_denselyOrdered_mrange [MulArchimedean (MonoidHom.mrange v)]
(hv : Integers v O) :
IsPrincipalIdealRing O ↔ ¬ DenselyOrdered (MonoidHom.mrange v) :=
isPrincipalIdealRing_iff_not_denselyOrdered hv | lemma | RingTheory | [
"Mathlib.GroupTheory.ArchimedeanDensely",
"Mathlib.RingTheory.Valuation.ValuationRing"
] | Mathlib/RingTheory/Valuation/Archimedean.lean | isPrincipalIdealRing_iff_not_denselyOrdered_mrange | null |
Valuation extends R →*₀ Γ₀ where
/-- The valuation of a sum is less than or equal to the maximum of the valuations. -/
map_add_le_max' : ∀ x y, toFun (x + y) ≤ max (toFun x) (toFun y) | structure | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | Valuation | The type of `Γ₀`-valued valuations on `R`.
When you extend this structure, make sure to extend `ValuationClass`. |
ValuationClass (F) (R Γ₀ : outParam Type*) [LinearOrderedCommMonoidWithZero Γ₀] [Ring R]
[FunLike F R Γ₀] : Prop
extends MonoidWithZeroHomClass F R Γ₀ where
/-- The valuation of a sum is less than or equal to the maximum of the valuations. -/
map_add_le_max (f : F) (x y : R) : f (x + y) ≤ max (f x) (f y)
export ValuationClass (map_add_le_max) | class | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | ValuationClass | `ValuationClass F α β` states that `F` is a type of valuations.
You should also extend this typeclass when you extend `Valuation`. |
@[simp]
coe_mk (f : R →*₀ Γ₀) (h) : ⇑(Valuation.mk f h) = f := rfl | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | coe_mk | null |
toFun_eq_coe (v : Valuation R Γ₀) : v.toFun = v := rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | toFun_eq_coe | null |
toMonoidWithZeroHom_coe_eq_coe (v : Valuation R Γ₀) :
(v.toMonoidWithZeroHom : R → Γ₀) = v := rfl
@[ext] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | toMonoidWithZeroHom_coe_eq_coe | null |
ext {v₁ v₂ : Valuation R Γ₀} (h : ∀ r, v₁ r = v₂ r) : v₁ = v₂ :=
DFunLike.ext _ _ h
variable (v : Valuation R Γ₀)
@[simp, norm_cast] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | ext | null |
coe_coe : ⇑(v : R →*₀ Γ₀) = v := rfl | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | coe_coe | null |
protected map_zero : v 0 = 0 :=
v.map_zero' | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_zero | null |
protected map_one : v 1 = 1 :=
v.map_one' | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_one | null |
protected map_mul : ∀ x y, v (x * y) = v x * v y :=
v.map_mul' | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_mul | null |
protected map_add : ∀ x y, v (x + y) ≤ max (v x) (v y) :=
v.map_add_le_max'
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_add | null |
map_add' : ∀ x y, v (x + y) ≤ v x ∨ v (x + y) ≤ v y := by
intro x y
rw [← le_max_iff, ← ge_iff_le]
apply v.map_add | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_add' | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.