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 ⌀ |
|---|---|---|---|---|---|---|
eq_algebraMap_or_inv_eq_algebraMap (hv : Integers v O) (x : F) :
∃ a : O, x = algebraMap O F a ∨ x⁻¹ = algebraMap O F a := by
rcases val_le_one_or_val_inv_le_one v x with h | h <;>
obtain ⟨a, ha⟩ := exists_of_le_one hv h
exacts [⟨a, Or.inl ha.symm⟩, ⟨a, Or.inr ha.symm⟩] | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | eq_algebraMap_or_inv_eq_algebraMap | null |
coe_span_singleton_eq_setOf_le_v_algebraMap (hv : Integers v O) (x : O) :
(Ideal.span {x} : Set O) = {y : O | v (algebraMap O F y) ≤ v (algebraMap O F x)} := by
rcases eq_or_ne x 0 with rfl | hx
· simp [Set.singleton_zero, Ideal.span_zero, map_eq_zero_iff _ hv.hom_inj]
ext
simp [SetLike.mem_coe, Ideal.mem_span_singleton, hv.dvd_iff_le] | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | coe_span_singleton_eq_setOf_le_v_algebraMap | null |
bijective_algebraMap_of_subsingleton_units_mrange (hv : Integers v O)
[Subsingleton (MonoidHom.mrange v)ˣ] :
Function.Bijective (algebraMap O F) := by
refine ⟨hv.hom_inj, fun x ↦ hv.exists_of_le_one ?_⟩
rcases eq_or_ne x 0 with rfl | hx
· simp
· exact (congr_arg Units.val (Subsingleton.elim (α := (MonoidHom.mrange v)ˣ)
((isUnit_iff_ne_zero.mpr hx).unit.map v.toMonoidHom.mrangeRestrict) 1)).le | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | bijective_algebraMap_of_subsingleton_units_mrange | null |
isPrincipal_iff_exists_isGreatest (hv : Integers v O) {I : Ideal O} :
I.IsPrincipal ↔ ∃ x, IsGreatest (v ∘ algebraMap O F '' I) x := by
constructor <;> rintro ⟨x, hx⟩
· refine ⟨(v ∘ algebraMap O F) x, ?_, ?_⟩
· refine Set.mem_image_of_mem _ ?_
simp [hx, Ideal.mem_span_singleton_self]
· intro y hy
simp only [Function.comp_apply, hx, Ideal.submodule_span_eq, Set.mem_image,
SetLike.mem_coe, Ideal.mem_span_singleton] at hy
obtain ⟨y, hy, rfl⟩ := hy
exact le_of_dvd hv hy
· obtain ⟨a, ha, rfl⟩ : ∃ a ∈ I, (v ∘ algebraMap O F) a = x := by simpa using hx.left
refine ⟨a, ?_⟩
ext b
simp only [Ideal.submodule_span_eq, Ideal.mem_span_singleton]
exact ⟨fun hb ↦ dvd_of_le hv (hx.2 <| mem_image_of_mem _ hb), fun hb ↦ I.mem_of_dvd hb ha⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | isPrincipal_iff_exists_isGreatest | null |
isPrincipal_iff_exists_eq_setOf_valuation_le (hv : Integers v O) {I : Ideal O} :
I.IsPrincipal ↔ ∃ x, (I : Set O) = {y | v (algebraMap O F y) ≤ v (algebraMap O F x)} := by
rw [isPrincipal_iff_exists_isGreatest hv]
constructor <;> rintro ⟨x, hx⟩
· obtain ⟨a, ha, rfl⟩ : ∃ a ∈ I, (v ∘ algebraMap O F) a = x := by simpa using hx.left
refine ⟨a, ?_⟩
ext b
simp only [SetLike.mem_coe, mem_setOf_eq]
constructor <;> intro h
· exact hx.right (Set.mem_image_of_mem _ h)
· rw [le_iff_dvd hv] at h
exact Ideal.mem_of_dvd I h ha
· refine ⟨v (algebraMap O F x), Set.mem_image_of_mem _ ?_, ?_⟩
· simp [hx]
· simp [hx, mem_upperBounds] | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | isPrincipal_iff_exists_eq_setOf_valuation_le | null |
not_denselyOrdered_of_isPrincipalIdealRing [IsPrincipalIdealRing O] (hv : Integers v O) :
¬ DenselyOrdered (range v) := by
intro H
set I : Ideal O := {
carrier := v ∘ algebraMap O F ⁻¹' Iio (1 : Γ₀)
add_mem' := fun {a b} ha hb ↦ by simpa using map_add_lt v ha hb
zero_mem' := by simp
smul_mem' := by
intro c x
simp only [mem_preimage, Function.comp_apply, mem_Iio, smul_eq_mul, map_mul]
intro hx
exact Right.mul_lt_one_of_le_of_lt (hv.map_le_one c) hx
}
obtain ⟨x, hx₁, hx⟩ :
∃ x, v (algebraMap O F x) < 1 ∧
v (algebraMap O F x) ∈ upperBounds (Iio 1 ∩ range (v ∘ algebraMap O F)) := by
simpa [I, IsGreatest, hv.isPrincipal_iff_exists_isGreatest, ← image_preimage_eq_inter_range]
using IsPrincipalIdealRing.principal I
obtain ⟨y, hy, hy₁⟩ : ∃ y, v (algebraMap O F x) < v y ∧ v y < 1 := by
simpa only [Subtype.exists, Subtype.mk_lt_mk, exists_range_iff, exists_prop]
using H.dense ⟨v (algebraMap O F x), mem_range_self _⟩ ⟨1, 1, v.map_one⟩ hx₁
obtain ⟨z, rfl⟩ := hv.exists_of_le_one hy₁.le
exact hy.not_ge <| hx ⟨hy₁, mem_range_self _⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | not_denselyOrdered_of_isPrincipalIdealRing | null |
Integer.not_isUnit_iff_valuation_lt_one {x : v.integer} : ¬IsUnit x ↔ v x < 1 := by
rw [← not_le, not_iff_not, isUnit_iff_valuation_eq_one (F := F) (Γ₀ := Γ₀),
le_antisymm_iff]
exacts [and_iff_right x.2, integer.integers v] | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | Integer.not_isUnit_iff_valuation_lt_one | null |
v_irreducible_lt_one {ϖ : v.integer} (h : Irreducible ϖ) :
v ϖ < 1 :=
(Valuation.integer.integers v).valuation_irreducible_lt_one h | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | v_irreducible_lt_one | null |
v_irreducible_pos {ϖ : v.integer} (h : Irreducible ϖ) : 0 < v ϖ :=
(Valuation.integer.integers v).valuation_irreducible_pos h | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | v_irreducible_pos | null |
coe_span_singleton_eq_setOf_le_v_coe (x : v.integer) :
(Ideal.span {x} : Set v.integer) = {y : v.integer | v y ≤ v x} :=
(Valuation.integer.integers v).coe_span_singleton_eq_setOf_le_v_algebraMap x | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | coe_span_singleton_eq_setOf_le_v_coe | null |
isIntegral_iff_v_le_one {x : R} :
IsIntegral O x ↔ v x ≤ 1 := by
nontriviality R
have : Nontrivial O := hv.nontrivial_iff.mpr inferInstance
constructor
· rintro ⟨f, hm, hf⟩
by_cases hn : f.natDegree = 0
· rw [Polynomial.natDegree_eq_zero] at hn
obtain ⟨c, rfl⟩ := hn
simp [map_eq_zero_iff _ hv.hom_inj, hm.ne_zero_of_C] at hf
simp only [Polynomial.eval₂_eq_sum_range, Finset.sum_range_succ, hm.coeff_natDegree, map_one,
one_mul, add_eq_zero_iff_eq_neg] at hf
apply_fun v at hf
simp only [map_neg, map_pow] at hf
contrapose! hf
refine ne_of_lt (v.map_sum_lt ?_ ?_)
· simp [hn, (hf.trans' (zero_lt_one)).ne']
· simp only [Finset.mem_range, map_mul, map_pow]
intro _ hi
exact mul_lt_of_le_one_of_lt (hv.map_le_one _) <| pow_lt_pow_right₀ hf hi
· intro h
obtain ⟨y, rfl⟩ := hv.exists_of_le_one h
exact ⟨Polynomial.X - .C y, by monicity, by simp⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.IntegralClosure.IntegrallyClosed",
"Mathlib.RingTheory.Valuation.ValuationRing"
] | Mathlib/RingTheory/Valuation/Integral.lean | isIntegral_iff_v_le_one | null |
mem_of_integral {x : R} (hx : IsIntegral O x) : x ∈ v.integer :=
hv.isIntegral_iff_v_le_one.mp hx | theorem | RingTheory | [
"Mathlib.RingTheory.IntegralClosure.IntegrallyClosed",
"Mathlib.RingTheory.Valuation.ValuationRing"
] | Mathlib/RingTheory/Valuation/Integral.lean | mem_of_integral | null |
protected integralClosure : integralClosure O R = ⊥ :=
bot_unique fun _ hr =>
let ⟨x, hx⟩ := hv.3 (hv.mem_of_integral hr)
Algebra.mem_bot.2 ⟨x, hx⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.IntegralClosure.IntegrallyClosed",
"Mathlib.RingTheory.Valuation.ValuationRing"
] | Mathlib/RingTheory/Valuation/Integral.lean | integralClosure | null |
isIntegrallyClosed : IsIntegrallyClosed O := by
have : IsFractionRing O K := hv.isFractionRing
exact
(IsIntegrallyClosed.integralClosure_eq_bot_iff K).mp (Valuation.Integers.integralClosure hv)
@[deprecated (since := "2025-09-04")] alias integrallyClosed := isIntegrallyClosed | theorem | RingTheory | [
"Mathlib.RingTheory.IntegralClosure.IntegrallyClosed",
"Mathlib.RingTheory.Valuation.ValuationRing"
] | Mathlib/RingTheory/Valuation/Integral.lean | isIntegrallyClosed | null |
isIntegrallyClosed_integers (v : Valuation K Γ₀) :
IsIntegrallyClosed v.integer :=
(Valuation.integer.integers v).isIntegrallyClosed | instance | RingTheory | [
"Mathlib.RingTheory.IntegralClosure.IntegrallyClosed",
"Mathlib.RingTheory.Valuation.ValuationRing"
] | Mathlib/RingTheory/Valuation/Integral.lean | isIntegrallyClosed_integers | null |
ValuationSubring.toLocalSubring (A : ValuationSubring K) : LocalSubring K where
toSubring := A.toSubring
isLocalRing := A.isLocalRing | def | RingTheory | [
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.LocalRing.LocalSubring",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/LocalSubring.lean | ValuationSubring.toLocalSubring | Cast a valuation subring to a local subring. |
ValuationSubring.toLocalSubring_injective :
Function.Injective (ValuationSubring.toLocalSubring (K := K)) :=
fun _ _ h ↦ ValuationSubring.toSubring_injective congr(($h).toSubring) | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.LocalRing.LocalSubring",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/LocalSubring.lean | ValuationSubring.toLocalSubring_injective | null |
LocalSubring.map_maximalIdeal_eq_top_of_isMax {R : LocalSubring K}
(hR : IsMax R) {S : Subring K} (hS : R.toSubring < S) :
(maximalIdeal R.toSubring).map (Subring.inclusion hS.le) = ⊤ := by
let mR := (maximalIdeal R.toSubring).map (Subring.inclusion hS.le)
by_contra h_is_not_top
obtain ⟨M, h_is_max, h_incl⟩ := Ideal.exists_le_maximal _ h_is_not_top
let fSₘ : LocalSubring K := LocalSubring.ofPrime S M
have h_RleSₘ : R ≤ fSₘ := by
refine ⟨hS.le.trans (LocalSubring.le_ofPrime _ _), ⟨?_⟩⟩
rintro ⟨a, h_a_inR⟩ h_fa_isUnit
apply (IsLocalization.AtPrime.isUnit_to_map_iff _ M ⟨a, hS.le h_a_inR⟩).mp at h_fa_isUnit
by_contra h
rw [← mem_nonunits_iff, ← mem_maximalIdeal] at h
apply Ideal.mem_map_of_mem (Subring.inclusion hS.le) at h
exact h_fa_isUnit (h_incl h)
have h_RneSₘ : R ≠ fSₘ :=
fun e ↦ (hS.trans_le (LocalSubring.le_ofPrime S M)).ne congr(($e).toSubring)
exact h_RneSₘ (hR.eq_of_le h_RleSₘ)
@[stacks 00IC] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.LocalRing.LocalSubring",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/LocalSubring.lean | LocalSubring.map_maximalIdeal_eq_top_of_isMax | null |
LocalSubring.mem_of_isMax_of_isIntegral {R : LocalSubring K}
(hR : IsMax R) {x : K} (hx : IsIntegral R.toSubring x) : x ∈ R.toSubring := by
let S := Algebra.adjoin R.toSubring {x}
have : Algebra.IsIntegral R.toSubring S := Algebra.IsIntegral.adjoin (by simpa)
have : FaithfulSMul R.toSubring S := NoZeroSMulDivisors.instFaithfulSMulOfNontrivial
obtain ⟨Q : Ideal S.toSubring, hQ, e⟩ := Ideal.exists_ideal_over_maximal_of_isIntegral
(R := R.toSubring) (S := S) (maximalIdeal _) (le_maximalIdeal (by simp))
have : R = .ofPrime S.toSubring Q := by
have hRS : R.toSubring ≤ S.toSubring := fun r hr ↦ algebraMap_mem S ⟨r, hr⟩
apply hR.eq_of_le ⟨hRS.trans (LocalSubring.le_ofPrime _ _), ⟨?_⟩⟩
intro r hr
have := (IsLocalization.AtPrime.isUnit_to_map_iff (R := S.toSubring) _ Q ⟨_, hRS r.2⟩).mp hr
by_contra h
rw [← mem_nonunits_iff, ← mem_maximalIdeal, ← e] at h
exact this h
rw [this]
exact LocalSubring.le_ofPrime _ _ (Algebra.self_mem_adjoin_singleton _ _)
@[stacks 052K] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.LocalRing.LocalSubring",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/LocalSubring.lean | LocalSubring.mem_of_isMax_of_isIntegral | null |
ValuationSubring.isMax_toLocalSubring (R : ValuationSubring K) :
IsMax R.toLocalSubring := by
intro S hS
suffices R.toLocalSubring = S from this.ge
refine LocalSubring.toSubring_injective (le_antisymm hS.1 ?_)
intro x hx
refine (R.2 x).elim id fun h ↦ ?_
by_contra h'
have hx0 : x ≠ 0 := by rintro rfl; exact h' (zero_mem R)
have : IsUnit (Subring.inclusion hS.1 ⟨x⁻¹, h⟩) :=
isUnit_iff_exists_inv.mpr ⟨⟨x, hx⟩, Subtype.ext (inv_mul_cancel₀ hx0)⟩
obtain ⟨x', hx'⟩ := isUnit_iff_exists_inv.mp (hS.2.1 _ this)
have : x'.1 = x := by simpa [Subtype.ext_iff, inv_mul_eq_iff_eq_mul₀ hx0] using hx'
exact h' (this ▸ x'.2)
@[stacks 00IB] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.LocalRing.LocalSubring",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/LocalSubring.lean | ValuationSubring.isMax_toLocalSubring | null |
LocalSubring.exists_valuationRing_of_isMax {R : LocalSubring K} (hR : IsMax R) :
∃ R' : ValuationSubring K, R'.toLocalSubring = R := by
suffices ∀ x ∉ R.toSubring, x⁻¹ ∈ R.toSubring from
⟨⟨R.toSubring, fun x ↦ or_iff_not_imp_left.mpr (this x)⟩, rfl⟩
intro x hx
have hx0 : x ≠ 0 := fun e ↦ hx (e ▸ zero_mem _)
apply mem_of_isMax_of_isIntegral hR
let S := Algebra.adjoin R.toSubring {x}
have : R.toSubring < S.toSubring := SetLike.lt_iff_le_and_exists.mpr
⟨fun r hr ↦ algebraMap_mem S ⟨r, hr⟩, ⟨x, Algebra.self_mem_adjoin_singleton _ _, hx⟩⟩
have := map_maximalIdeal_eq_top_of_isMax hR this
rw [Ideal.eq_top_iff_one] at this
obtain ⟨p, hp, hp'⟩ := (Algebra.mem_ideal_map_adjoin _ _).mp this
have := IsUnit.invertible (isUnit_iff_ne_zero.mpr hx0)
have : Polynomial.aeval (⅟x) (p - 1).reverse = 0 := by
simpa [← Polynomial.aeval_def, hp'] using
Polynomial.eval₂_reverse_eq_zero_iff (algebraMap R.toSubring K) x (p - 1)
rw [invOf_eq_right_inv (mul_inv_cancel₀ hx0)] at this
have H : IsUnit ((p - 1).coeff 0) := by
by_contra h
simpa using sub_mem (hp 0) h
refine ⟨.C (H.unit⁻¹).1 * (p - 1).reverse, ?_, ?_⟩
· have : (p - 1).natTrailingDegree = 0 := by
simp only [Polynomial.natTrailingDegree_eq_zero,
Polynomial.coeff_sub, Polynomial.coeff_one_zero, ne_eq, sub_eq_zero]
exact .inr fun h ↦ (IsLocalRing.notMem_maximalIdeal.mpr isUnit_one (h ▸ hp 0))
rw [Polynomial.Monic.def, Polynomial.leadingCoeff_mul', Polynomial.reverse_leadingCoeff,
Polynomial.trailingCoeff, this]
· simp
· have : p - 1 ≠ 0 := fun e ↦ by simp [e] at H
simpa
· simp [← Polynomial.aeval_def, this] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.LocalRing.LocalSubring",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/LocalSubring.lean | LocalSubring.exists_valuationRing_of_isMax | null |
LocalSubring.isMax_iff {A : LocalSubring K} :
IsMax A ↔ ∃ B : ValuationSubring K, B.toLocalSubring = A :=
⟨exists_valuationRing_of_isMax, fun ⟨B, e⟩ ↦ e ▸ B.isMax_toLocalSubring⟩
@[stacks 00IA] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.LocalRing.LocalSubring",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/LocalSubring.lean | LocalSubring.isMax_iff | A local subring is maximal with respect to the domination order
if and only if it is a valuation ring. |
LocalSubring.exists_le_valuationSubring (A : LocalSubring K) :
∃ B : ValuationSubring K, A ≤ B.toLocalSubring := by
suffices ∃ B, A ≤ B ∧ IsMax B by
obtain ⟨B, hB, hB'⟩ := this
obtain ⟨B, rfl⟩ := B.exists_valuationRing_of_isMax hB'
exact ⟨B, hB⟩
refine zorn_le_nonempty_Ici₀ _ ?_ _ le_rfl
intro s hs H y hys
have inst : Nonempty s := ⟨⟨y, hys⟩⟩
have hdir := H.directed.mono_comp _ LocalSubring.toSubring_mono
refine ⟨@LocalSubring.mk _ _ (⨆ i : s, i.1.toSubring) ⟨?_⟩, ?_⟩
· intro ⟨a, ha⟩ ⟨b, hb⟩ e
obtain ⟨A, haA : a ∈ A.1.toSubring⟩ := (Subring.mem_iSup_of_directed hdir).mp ha
obtain ⟨B, hbB : b ∈ B.1.toSubring⟩ := (Subring.mem_iSup_of_directed hdir).mp hb
obtain ⟨C, hCA, hCB⟩ := hdir A B
refine (C.1.2.2 (a := ⟨a, hCA haA⟩) (b := ⟨b, hCB hbB⟩) (Subtype.ext congr(($e).1))).imp ?_ ?_
· exact fun h ↦ h.map (Subring.inclusion (le_iSup (fun i : s ↦ i.1.toSubring) C))
· exact fun h ↦ h.map (Subring.inclusion (le_iSup (fun i : s ↦ i.1.toSubring) C))
· intro A hA
refine ⟨le_iSup (fun i : s ↦ i.1.toSubring) ⟨A, hA⟩, ⟨?_⟩⟩
rintro ⟨a, haA⟩ h
obtain ⟨⟨b, hb⟩, e⟩ := isUnit_iff_exists_inv.mp h
obtain ⟨B, hbB : b ∈ B.1.toSubring⟩ := (Subring.mem_iSup_of_directed hdir).mp hb
obtain ⟨C, hCA, hCB⟩ := H.directed ⟨A, hA⟩ B
apply hCA.2.1
exact isUnit_iff_exists_inv.mpr ⟨⟨b, hCB.1 hbB⟩, Subtype.ext congr(($e).1)⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.LocalRing.LocalSubring",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/LocalSubring.lean | LocalSubring.exists_le_valuationSubring | null |
bijective_rangeRestrict_comp_of_valuationRing [IsDomain R] [ValuationRing R]
[IsLocalRing S] [Algebra R K] [IsFractionRing R K]
(f : R →+* S) (g : S →+* K) (h : g.comp f = algebraMap R K) [IsLocalHom f] :
Function.Bijective (g.rangeRestrict.comp f) := by
refine ⟨?_, ?_⟩
· exact .of_comp (f := Subtype.val) (by convert (IsFractionRing.injective R K); rw [← h]; rfl)
· let V : ValuationSubring K :=
⟨(algebraMap R K).range, ValuationRing.isInteger_or_isInteger R⟩
suffices LocalSubring.range g ≤ V.toLocalSubring by
rintro ⟨_, x, rfl⟩
obtain ⟨y, hy⟩ := this.1 ⟨x, rfl⟩
exact ⟨y, Subtype.ext (by simpa [← h] using hy)⟩
apply V.isMax_toLocalSubring
have H : (algebraMap R K).range ≤ g.range := fun x ⟨a, ha⟩ ↦ ⟨f a, by simp [← ha, ← h]⟩
refine ⟨H, ⟨?_⟩⟩
rintro ⟨_, a, rfl⟩ (ha : IsUnit (M := g.range) ⟨algebraMap R K a, _⟩)
suffices IsUnit a from this.map (algebraMap R K).rangeRestrict
apply IsUnit.of_map f
apply (IsLocalHom.of_surjective g.rangeRestrict g.rangeRestrict_surjective).1
convert ha
simp [← h] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.LocalRing.LocalSubring",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/LocalSubring.lean | bijective_rangeRestrict_comp_of_valuationRing | null |
IsLocalRing.exists_factor_valuationRing [IsLocalRing R] (f : R →+* K) :
∃ (A : ValuationSubring K) (h : _), IsLocalHom (f.codRestrict A.toSubring h) := by
obtain ⟨B, hB⟩ := (LocalSubring.range f).exists_le_valuationSubring
refine ⟨B, fun x ↦ hB.1 ⟨x, rfl⟩, ?_⟩
exact @RingHom.isLocalHom_comp _ _ _ _ _ _ _ _
hB.2 (.of_surjective _ f.rangeRestrict_surjective) | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.LocalRing.LocalSubring",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/LocalSubring.lean | IsLocalRing.exists_factor_valuationRing | null |
@[simp]
coeff_zero_minpoly (x : K) : v ((minpoly K (algebraMap K L x)).coeff 0) = v x := by
rw [minpoly.eq_X_sub_C, coeff_sub, coeff_X_zero, coeff_C_zero, zero_sub, Valuation.map_neg]
variable {L}
/- For any unit `x : Lˣ`, we prove that a certain power of the valuation of zeroth coefficient of
the minimal polynomial of `x` over `K` is nonzero. This lemma is helpful for defining the valuation
on `L` inducing `v`. -/ | theorem | RingTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Minpoly.lean | coeff_zero_minpoly | For `x ∈ K` the valuation of the zeroth coefficient of the minimal polynomial
of `algebra_map K L x` over `K` is equal to the valuation of `x`. |
pow_coeff_zero_ne_zero_of_unit [FiniteDimensional K L] (x : L) (hx : IsUnit x) :
v ((minpoly K x).coeff 0) ^ (finrank K L / (minpoly K x).natDegree) ≠ (0 : Γ₀) := by
have h_alg : Algebra.IsAlgebraic K L := Algebra.IsAlgebraic.of_finite K L
have hx₀ : IsIntegral K x := (Algebra.IsAlgebraic.isAlgebraic x).isIntegral
have hdeg := Nat.div_pos (natDegree_le x) (natDegree_pos hx₀)
rw [ne_eq, pow_eq_zero_iff hdeg.ne.symm, Valuation.zero_iff]
exact coeff_zero_ne_zero hx₀ hx.ne_zero | theorem | RingTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Minpoly.lean | pow_coeff_zero_ne_zero_of_unit | null |
noncomputable multiplicity_addValuation (hp : Prime p) : AddValuation R ℕ∞ :=
AddValuation.of (emultiplicity p) (emultiplicity_zero _) (emultiplicity_of_one_right hp.not_unit)
(fun _ _ => min_le_emultiplicity_add) fun _ _ => emultiplicity_mul hp
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/PrimeMultiplicity.lean | multiplicity_addValuation | `multiplicity` of a prime in an integral domain as an additive valuation to `ℕ∞`. |
multiplicity_addValuation_apply {hp : Prime p} {r : R} :
multiplicity_addValuation hp r = emultiplicity p r :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Multiplicity",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/PrimeMultiplicity.lean | multiplicity_addValuation_apply | null |
onQuotVal {J : Ideal R} (hJ : J ≤ supp v) : R ⧸ J → Γ₀ := fun q =>
Quotient.liftOn' q v fun a b h =>
calc
v a = v (b + -(-a + b)) := by simp
_ = v b :=
v.map_add_supp b <| (Ideal.neg_mem_iff _).2 <| hJ <| QuotientAddGroup.leftRel_apply.mp h | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Quotient.lean | onQuotVal | If `hJ : J ⊆ supp v` then `onQuotVal hJ` is the induced function on `R / J` as a function.
Note: it's just the function; the valuation is `onQuot hJ`. |
onQuot {J : Ideal R} (hJ : J ≤ supp v) : Valuation (R ⧸ J) Γ₀ where
toFun := v.onQuotVal hJ
map_zero' := v.map_zero
map_one' := v.map_one
map_mul' xbar ybar := Quotient.ind₂' v.map_mul xbar ybar
map_add_le_max' xbar ybar := Quotient.ind₂' v.map_add xbar ybar
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Quotient.lean | onQuot | The extension of valuation `v` on `R` to valuation on `R / J` if `J ⊆ supp v`. |
onQuot_comap_eq {J : Ideal R} (hJ : J ≤ supp v) :
(v.onQuot hJ).comap (Ideal.Quotient.mk J) = v :=
ext fun _ => rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Quotient.lean | onQuot_comap_eq | null |
self_le_supp_comap (J : Ideal R) (v : Valuation (R ⧸ J) Γ₀) :
J ≤ (v.comap (Ideal.Quotient.mk J)).supp := by
rw [comap_supp, ← Ideal.map_le_iff_le_comap]
simp
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Quotient.lean | self_le_supp_comap | null |
comap_onQuot_eq (J : Ideal R) (v : Valuation (R ⧸ J) Γ₀) :
(v.comap (Ideal.Quotient.mk J)).onQuot (v.self_le_supp_comap J) = v :=
ext <| by
rintro ⟨x⟩
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Quotient.lean | comap_onQuot_eq | null |
supp_quot {J : Ideal R} (hJ : J ≤ supp v) :
supp (v.onQuot hJ) = (supp v).map (Ideal.Quotient.mk J) := by
apply le_antisymm
· rintro ⟨x⟩ hx
apply Ideal.subset_span
exact ⟨x, hx, rfl⟩
· rw [Ideal.map_le_iff_le_comap]
intro x hx
exact hx | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Quotient.lean | supp_quot | The quotient valuation on `R / J` has support `(supp v) / J` if `J ⊆ supp v`. |
supp_quot_supp : supp (v.onQuot le_rfl) = 0 := by
rw [supp_quot]
exact Ideal.map_quotient_self _ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Quotient.lean | supp_quot_supp | null |
onQuotVal {J : Ideal R} (hJ : J ≤ supp v) : R ⧸ J → Γ₀ :=
Valuation.onQuotVal v hJ | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Quotient.lean | onQuotVal | If `hJ : J ⊆ supp v` then `onQuotVal hJ` is the induced function on `R / J` as a function.
Note: it's just the function; the valuation is `onQuot hJ`. |
onQuot {J : Ideal R} (hJ : J ≤ supp v) : AddValuation (R ⧸ J) Γ₀ :=
Valuation.onQuot v hJ
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Quotient.lean | onQuot | The extension of valuation `v` on `R` to valuation on `R / J` if `J ⊆ supp v`. |
onQuot_comap_eq {J : Ideal R} (hJ : J ≤ supp v) :
(v.onQuot hJ).comap (Ideal.Quotient.mk J) = v :=
Valuation.onQuot_comap_eq v hJ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Quotient.lean | onQuot_comap_eq | null |
comap_supp {S : Type*} [CommRing S] (f : S →+* R) :
supp (v.comap f) = Ideal.comap f v.supp :=
Valuation.comap_supp v f | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Quotient.lean | comap_supp | null |
self_le_supp_comap (J : Ideal R) (v : AddValuation (R ⧸ J) Γ₀) :
J ≤ (v.comap (Ideal.Quotient.mk J)).supp :=
Valuation.self_le_supp_comap J v
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Quotient.lean | self_le_supp_comap | null |
comap_onQuot_eq (J : Ideal R) (v : AddValuation (R ⧸ J) Γ₀) :
(v.comap (Ideal.Quotient.mk J)).onQuot (v.self_le_supp_comap J) = v :=
Valuation.comap_onQuot_eq J v | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Quotient.lean | comap_onQuot_eq | null |
supp_quot {J : Ideal R} (hJ : J ≤ supp v) :
supp (v.onQuot hJ) = (supp v).map (Ideal.Quotient.mk J) :=
Valuation.supp_quot v hJ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Quotient.lean | supp_quot | The quotient valuation on `R / J` has support `(supp v) / J` if `J ⊆ supp v`. |
supp_quot_supp : supp ((Valuation.onQuot v) le_rfl) = 0 :=
Valuation.supp_quot_supp v | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Quotient.lean | supp_quot_supp | null |
decompositionSubgroup (A : ValuationSubring L) : Subgroup (L ≃ₐ[K] L) :=
MulAction.stabilizer (L ≃ₐ[K] L) A | abbrev | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/RamificationGroup.lean | decompositionSubgroup | The decomposition subgroup defined as the stabilizer of the action
on the type of all valuation subrings of the field. |
subMulAction (A : ValuationSubring L) : SubMulAction (A.decompositionSubgroup K) L where
carrier := A
smul_mem' g _ h := Set.mem_of_mem_of_subset (Set.smul_mem_smul_set h) g.prop.le | def | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/RamificationGroup.lean | subMulAction | The valuation subring `A` (considered as a subset of `L`)
is stable under the action of the decomposition group. |
decompositionSubgroupMulSemiringAction (A : ValuationSubring L) :
MulSemiringAction (A.decompositionSubgroup K) A :=
{ SubMulAction.mulAction (A.subMulAction K) with
smul_add := fun g k l => Subtype.ext <| smul_add (A := L) g k l
smul_zero := fun g => Subtype.ext <| smul_zero g
smul_one := fun g => Subtype.ext <| smul_one g
smul_mul := fun g k l => Subtype.ext <| smul_mul' (N := L) g k l } | instance | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/RamificationGroup.lean | decompositionSubgroupMulSemiringAction | The multiplicative action of the decomposition subgroup on `A`. |
noncomputable inertiaSubgroup (A : ValuationSubring L) : Subgroup (A.decompositionSubgroup K) :=
MonoidHom.ker <|
MulSemiringAction.toRingAut (A.decompositionSubgroup K) (IsLocalRing.ResidueField A) | def | RingTheory | [
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/RamificationGroup.lean | inertiaSubgroup | The inertia subgroup defined as the kernel of the group homomorphism from
the decomposition subgroup to the group of automorphisms of the residue field of `A`. |
RankOne (v : Valuation R Γ₀) extends Valuation.IsNontrivial v where
/-- The inclusion morphism from `Γ₀` to `ℝ≥0`. -/
hom : Γ₀ →*₀ ℝ≥0
strictMono' : StrictMono hom
open WithZero | class | RingTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.GroupWithZero.WithZero",
"Mathlib.Analysis.SpecialFunctions.Pow.Real",
"Mathlib.Data.Real.Embedding",
"Mathlib.RingTheory.Valuation.ValuativeRel.Basic"
] | Mathlib/RingTheory/Valuation/RankOne.lean | RankOne | A valuation has rank one if it is nontrivial and its image is contained in `ℝ≥0`.
Note that this class includes the data of an inclusion morphism `Γ₀ → ℝ≥0`. |
nonempty_rankOne_iff_mulArchimedean {v : Valuation R Γ₀} [v.IsNontrivial] :
Nonempty v.RankOne ↔ MulArchimedean Γ₀ := by
constructor
· rintro ⟨⟨f, hf⟩⟩
exact .comap f.toMonoidHom hf
· intro _
obtain ⟨f, hf⟩ := Archimedean.exists_orderAddMonoidHom_real_injective (Additive Γ₀ˣ)
let e := AddMonoidHom.toMultiplicative' (α := Γ₀ˣ) (β := ℝ) f
have he : StrictMono e := by
simp only [AddMonoidHom.coe_toMultiplicative', AddMonoidHom.coe_coe, e]
exact StrictMono.comp strictMono_id (f.monotone'.strictMono_of_injective hf)
let rf : Multiplicative ℝ →* ℝ≥0ˣ := {
toFun x := Units.mk0 ⟨(2 : ℝ) ^ (log (M := ℝ) x), by positivity⟩ <| by
rw [ne_eq, Subtype.ext_iff]
positivity
map_one' := by simp
map_mul' _ _ := by
rw [Units.ext_iff, Subtype.ext_iff]
simp [log_mul, Real.rpow_add]
}
have H : StrictMono (map' (rf.comp e)) := by
refine map'_strictMono ?_
intro a b h
simpa [← Units.val_lt_val, ← NNReal.coe_lt_coe, rf] using he h
exact ⟨{
hom := withZeroUnitsEquiv.toMonoidWithZeroHom.comp <| (map' (rf.comp e)).comp
withZeroUnitsEquiv.symm.toMonoidWithZeroHom
strictMono' := withZeroUnitsEquiv_strictMono.comp <| H.comp
withZeroUnitsEquiv_symm_strictMono
}⟩ | lemma | RingTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.GroupWithZero.WithZero",
"Mathlib.Analysis.SpecialFunctions.Pow.Real",
"Mathlib.Data.Real.Embedding",
"Mathlib.RingTheory.Valuation.ValuativeRel.Basic"
] | Mathlib/RingTheory/Valuation/RankOne.lean | nonempty_rankOne_iff_mulArchimedean | null |
strictMono : StrictMono (hom v) := strictMono' | lemma | RingTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.GroupWithZero.WithZero",
"Mathlib.Analysis.SpecialFunctions.Pow.Real",
"Mathlib.Data.Real.Embedding",
"Mathlib.RingTheory.Valuation.ValuativeRel.Basic"
] | Mathlib/RingTheory/Valuation/RankOne.lean | strictMono | null |
nontrivial : ∃ r : R, v r ≠ 0 ∧ v r ≠ 1 := IsNontrivial.exists_val_nontrivial | lemma | RingTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.GroupWithZero.WithZero",
"Mathlib.Analysis.SpecialFunctions.Pow.Real",
"Mathlib.Data.Real.Embedding",
"Mathlib.RingTheory.Valuation.ValuativeRel.Basic"
] | Mathlib/RingTheory/Valuation/RankOne.lean | nontrivial | null |
zero_of_hom_zero {x : Γ₀} (hx : hom v x = 0) : x = 0 := by
refine (eq_of_le_of_not_lt (zero_le' (a := x)) fun h_lt ↦ ?_).symm
have hs := strictMono v h_lt
rw [map_zero, hx] at hs
exact hs.false | theorem | RingTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.GroupWithZero.WithZero",
"Mathlib.Analysis.SpecialFunctions.Pow.Real",
"Mathlib.Data.Real.Embedding",
"Mathlib.RingTheory.Valuation.ValuativeRel.Basic"
] | Mathlib/RingTheory/Valuation/RankOne.lean | zero_of_hom_zero | If `v` is a rank one valuation and `x : Γ₀` has image `0` under `RankOne.hom v`, then
`x = 0`. |
hom_eq_zero_iff {x : Γ₀} : RankOne.hom v x = 0 ↔ x = 0 :=
⟨fun h ↦ zero_of_hom_zero v h, fun h ↦ by rw [h, map_zero]⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.GroupWithZero.WithZero",
"Mathlib.Analysis.SpecialFunctions.Pow.Real",
"Mathlib.Data.Real.Embedding",
"Mathlib.RingTheory.Valuation.ValuativeRel.Basic"
] | Mathlib/RingTheory/Valuation/RankOne.lean | hom_eq_zero_iff | If `v` is a rank one valuation, then`x : Γ₀` has image `0` under `RankOne.hom v` if and
only if `x = 0`. |
unit : Γ₀ˣ :=
Units.mk0 (v (nontrivial v).choose) ((nontrivial v).choose_spec).1 | def | RingTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.GroupWithZero.WithZero",
"Mathlib.Analysis.SpecialFunctions.Pow.Real",
"Mathlib.Data.Real.Embedding",
"Mathlib.RingTheory.Valuation.ValuativeRel.Basic"
] | Mathlib/RingTheory/Valuation/RankOne.lean | unit | A nontrivial unit of `Γ₀`, given that there exists a rank one `v : Valuation R Γ₀`. |
unit_ne_one : unit v ≠ 1 := by
rw [Ne, ← Units.val_inj, Units.val_one]
exact ((nontrivial v).choose_spec).2 | theorem | RingTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.GroupWithZero.WithZero",
"Mathlib.Analysis.SpecialFunctions.Pow.Real",
"Mathlib.Data.Real.Embedding",
"Mathlib.RingTheory.Valuation.ValuativeRel.Basic"
] | Mathlib/RingTheory/Valuation/RankOne.lean | unit_ne_one | A proof that `RankOne.unit v ≠ 1`. |
Valuation.RankOne.ofRankLeOneStruct [ValuativeRel.IsNontrivial R] (e : RankLeOneStruct R) :
Valuation.RankOne (valuation R) where
__ : Valuation.IsNontrivial (valuation R) := isNontrivial_iff_isNontrivial.mp inferInstance
hom := e.emb
strictMono' := e.strictMono | def | RingTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.GroupWithZero.WithZero",
"Mathlib.Analysis.SpecialFunctions.Pow.Real",
"Mathlib.Data.Real.Embedding",
"Mathlib.RingTheory.Valuation.ValuativeRel.Basic"
] | Mathlib/RingTheory/Valuation/RankOne.lean | Valuation.RankOne.ofRankLeOneStruct | A valuative relation has a rank one valuation when it is both nontrivial
and the rank is at most one. |
Valuation.RankOne.rankLeOneStruct (e : Valuation.RankOne (valuation R)) :
RankLeOneStruct R where
emb := e.hom
strictMono := e.strictMono | def | RingTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.GroupWithZero.WithZero",
"Mathlib.Analysis.SpecialFunctions.Pow.Real",
"Mathlib.Data.Real.Embedding",
"Mathlib.RingTheory.Valuation.ValuativeRel.Basic"
] | Mathlib/RingTheory/Valuation/RankOne.lean | Valuation.RankOne.rankLeOneStruct | Convert between the rank one statement on valuative relation's induced valuation. |
ValuativeRel.isRankLeOne_of_rankOne [h : (valuation R).RankOne] :
IsRankLeOne R :=
⟨⟨h.rankLeOneStruct⟩⟩ | lemma | RingTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.GroupWithZero.WithZero",
"Mathlib.Analysis.SpecialFunctions.Pow.Real",
"Mathlib.Data.Real.Embedding",
"Mathlib.RingTheory.Valuation.ValuativeRel.Basic"
] | Mathlib/RingTheory/Valuation/RankOne.lean | ValuativeRel.isRankLeOne_of_rankOne | null |
ValuativeRel.isNontrivial_of_rankOne [h : (valuation R).RankOne] :
ValuativeRel.IsNontrivial R :=
isNontrivial_iff_isNontrivial.mpr h.toIsNontrivial
open WithZero | lemma | RingTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.GroupWithZero.WithZero",
"Mathlib.Analysis.SpecialFunctions.Pow.Real",
"Mathlib.Data.Real.Embedding",
"Mathlib.RingTheory.Valuation.ValuativeRel.Basic"
] | Mathlib/RingTheory/Valuation/RankOne.lean | ValuativeRel.isNontrivial_of_rankOne | null |
ValuativeRel.isRankLeOne_iff_mulArchimedean :
IsRankLeOne R ↔ MulArchimedean (ValueGroupWithZero R) := by
constructor
· rintro ⟨⟨f, hf⟩⟩
exact .comap f.toMonoidHom hf
· intro h
by_cases H : IsNontrivial R
· rw [isNontrivial_iff_isNontrivial] at H
rw [← (valuation R).nonempty_rankOne_iff_mulArchimedean] at h
obtain ⟨f⟩ := h
exact isRankLeOne_of_rankOne
· refine ⟨⟨{ emb := 1, strictMono := ?_ }⟩⟩
intro a b
contrapose! H
obtain ⟨H, H'⟩ := H
rcases eq_or_ne a 0 with rfl | ha
· simp_all
rcases eq_or_ne a 1 with rfl | ha'
· exact ⟨⟨b, (H.trans' zero_lt_one).ne', H.ne'⟩⟩
· exact ⟨⟨a, ha, ha'⟩⟩ | lemma | RingTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.GroupWithZero.WithZero",
"Mathlib.Analysis.SpecialFunctions.Pow.Real",
"Mathlib.Data.Real.Embedding",
"Mathlib.RingTheory.Valuation.ValuativeRel.Basic"
] | Mathlib/RingTheory/Valuation/RankOne.lean | ValuativeRel.isRankLeOne_iff_mulArchimedean | null |
ValuativeRel.IsRankLeOne.of_compatible_mulArchimedean [MulArchimedean Γ₀]
(v : Valuation R Γ₀) [v.Compatible] :
ValuativeRel.IsRankLeOne R := by
rw [isRankLeOne_iff_mulArchimedean]
exact .comap (ValueGroupWithZero.embed v).toMonoidHom (ValueGroupWithZero.embed_strictMono v) | lemma | RingTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.GroupWithZero.WithZero",
"Mathlib.Analysis.SpecialFunctions.Pow.Real",
"Mathlib.Data.Real.Embedding",
"Mathlib.RingTheory.Valuation.ValuativeRel.Basic"
] | Mathlib/RingTheory/Valuation/RankOne.lean | ValuativeRel.IsRankLeOne.of_compatible_mulArchimedean | null |
PreValuationRing (A : Type u) [Mul A] : Prop where
cond' : ∀ a b : A, ∃ c : A, a * c = b ∨ b * c = a | class | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | PreValuationRing | A magma is called a `PreValuationRing` provided that for any pair
of elements `a b : A`, either `a` divides `b` or vice versa. |
PreValuationRing.cond {A : Type u} [Mul A] [PreValuationRing A] (a b : A) :
∃ c : A, a * c = b ∨ b * c = a := @PreValuationRing.cond' A _ _ _ _ | lemma | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | PreValuationRing.cond | null |
ValuationRing (A : Type u) [CommRing A] [IsDomain A] : Prop extends PreValuationRing A | class | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | ValuationRing | An integral domain is called a `ValuationRing` provided that for any pair
of elements `a b : A`, either `a` divides `b` or vice versa. |
ValueGroup : Type v := Quotient (MulAction.orbitRel Aˣ K) | def | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | ValueGroup | An abbreviation for `PreValuationRing.cond` which should save some writing. -/
alias ValuationRing.cond := PreValuationRing.cond
namespace ValuationRing
section
variable (A : Type u) [CommRing A]
variable (K : Type v) [Field K] [Algebra A K]
/-- The value group of the valuation ring `A`. Note: this is actually a group with zero. |
protected le_total (a b : ValueGroup A K) : a ≤ b ∨ b ≤ a := by
rcases a with ⟨a⟩; rcases b with ⟨b⟩
obtain ⟨xa, ya, hya, rfl⟩ : ∃ a b : A, _ := IsFractionRing.div_surjective a
obtain ⟨xb, yb, hyb, rfl⟩ : ∃ a b : A, _ := IsFractionRing.div_surjective b
have : (algebraMap A K) ya ≠ 0 := IsFractionRing.to_map_ne_zero_of_mem_nonZeroDivisors hya
have : (algebraMap A K) yb ≠ 0 := IsFractionRing.to_map_ne_zero_of_mem_nonZeroDivisors hyb
obtain ⟨c, h | h⟩ := ValuationRing.cond (xa * yb) (xb * ya)
· right
use c
rw [Algebra.smul_def]
field_simp
simp only [← RingHom.map_mul]; congr 1; linear_combination h
· left
use c
rw [Algebra.smul_def]
field_simp
simp only [← RingHom.map_mul]; congr 1; linear_combination h | theorem | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | le_total | null |
noncomputable linearOrder : LinearOrder (ValueGroup A K) where
le_refl := by rintro ⟨⟩; use 1; rw [one_smul]
le_trans := by rintro ⟨a⟩ ⟨b⟩ ⟨c⟩ ⟨e, rfl⟩ ⟨f, rfl⟩; use e * f; rw [mul_smul]
le_antisymm := by
rintro ⟨a⟩ ⟨b⟩ ⟨e, rfl⟩ ⟨f, hf⟩
by_cases hb : b = 0; · simp [hb]
have : IsUnit e := by
apply isUnit_of_dvd_one
use f
rw [mul_comm]
rw [← mul_smul, Algebra.smul_def] at hf
nth_rw 2 [← one_mul b] at hf
rw [← (algebraMap A K).map_one] at hf
exact IsFractionRing.injective _ _ (mul_right_cancel₀ hb hf).symm
apply Quotient.sound'
exact ⟨this.unit, rfl⟩
le_total := ValuationRing.le_total _ _
toDecidableLE := Classical.decRel _ | instance | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | linearOrder | null |
commGroupWithZero :
CommGroupWithZero (ValueGroup A K) :=
{ mul_assoc := by rintro ⟨a⟩ ⟨b⟩ ⟨c⟩; apply Quotient.sound'; rw [mul_assoc]
one_mul := by rintro ⟨a⟩; apply Quotient.sound'; rw [one_mul]
mul_one := by rintro ⟨a⟩; apply Quotient.sound'; rw [mul_one]
mul_comm := by rintro ⟨a⟩ ⟨b⟩; apply Quotient.sound'; rw [mul_comm]
zero_mul := by rintro ⟨a⟩; apply Quotient.sound'; rw [zero_mul]
mul_zero := by rintro ⟨a⟩; apply Quotient.sound'; rw [mul_zero]
inv_zero := by apply Quotient.sound'; rw [inv_zero]
mul_inv_cancel := by
rintro ⟨a⟩ ha
apply Quotient.sound'
use 1
simp only [one_smul]
apply (mul_inv_cancel₀ _).symm
contrapose ha
simp only [Classical.not_not] at ha ⊢
rw [ha]
rfl } | instance | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | commGroupWithZero | null |
noncomputable linearOrderedCommGroupWithZero :
LinearOrderedCommGroupWithZero (ValueGroup A K) :=
{ linearOrder .., commGroupWithZero .. with
mul_le_mul_left := by
rintro ⟨a⟩ ⟨b⟩ ⟨c, rfl⟩ ⟨d⟩
use c; simp only [Algebra.smul_def]; ring
zero_le_one := ⟨0, by rw [zero_smul]⟩
bot := 0
bot_le := by rintro ⟨a⟩; exact ⟨0, zero_smul ..⟩ } | instance | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | linearOrderedCommGroupWithZero | null |
noncomputable valuation : Valuation K (ValueGroup A K) where
toFun := Quotient.mk''
map_zero' := rfl
map_one' := rfl
map_mul' _ _ := rfl
map_add_le_max' := by
intro a b
obtain ⟨xa, ya, hya, rfl⟩ : ∃ a b : A, _ := IsFractionRing.div_surjective a
obtain ⟨xb, yb, hyb, rfl⟩ : ∃ a b : A, _ := IsFractionRing.div_surjective b
have : (algebraMap A K) ya ≠ 0 := IsFractionRing.to_map_ne_zero_of_mem_nonZeroDivisors hya
have : (algebraMap A K) yb ≠ 0 := IsFractionRing.to_map_ne_zero_of_mem_nonZeroDivisors hyb
obtain ⟨c, h | h⟩ := ValuationRing.cond (xa * yb) (xb * ya)
· apply le_trans _ (le_max_left _ _)
use c + 1
rw [Algebra.smul_def]
field_simp
simp only [← RingHom.map_mul, ← RingHom.map_add]
congr 1; linear_combination h
· apply le_trans _ (le_max_right _ _)
use c + 1
rw [Algebra.smul_def]
field_simp
simp only [← RingHom.map_mul, ← RingHom.map_add]
congr 1; linear_combination h | def | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | valuation | Any valuation ring induces a valuation on its fraction field. |
mem_integer_iff (x : K) : x ∈ (valuation A K).integer ↔ ∃ a : A, algebraMap A K a = x := by
constructor
· rintro ⟨c, rfl⟩
use c
rw [Algebra.smul_def, mul_one]
· rintro ⟨c, rfl⟩
use c
rw [Algebra.smul_def, mul_one] | theorem | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | mem_integer_iff | null |
noncomputable equivInteger : A ≃+* (valuation A K).integer :=
RingEquiv.ofBijective
(show A →ₙ+* (valuation A K).integer from
{ toFun := fun a => ⟨algebraMap A K a, (mem_integer_iff _ _ _).mpr ⟨a, rfl⟩⟩
map_mul' := fun _ _ => by ext1; exact (algebraMap A K).map_mul _ _
map_zero' := by ext1; exact (algebraMap A K).map_zero
map_add' := fun _ _ => by ext1; exact (algebraMap A K).map_add _ _ })
(by
constructor
· intro x y h
apply_fun (algebraMap (valuation A K).integer K) at h
exact IsFractionRing.injective _ _ h
· rintro ⟨-, ha⟩
rw [mem_integer_iff] at ha
obtain ⟨a, rfl⟩ := ha
exact ⟨a, rfl⟩)
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | equivInteger | The valuation ring `A` is isomorphic to the ring of integers of its associated valuation. |
coe_equivInteger_apply (a : A) : (equivInteger A K a : K) = algebraMap A K a := rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | coe_equivInteger_apply | null |
range_algebraMap_eq : (valuation A K).integer = (algebraMap A K).range := by
ext; exact mem_integer_iff _ _ _ | theorem | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | range_algebraMap_eq | null |
le_total_ideal : IsTotal (Ideal A) LE.le := by
constructor; intro α β
by_cases h : α ≤ β; · exact Or.inl h
rw [SetLike.le_def, not_forall] at h
push_neg at h
obtain ⟨a, h₁, h₂⟩ := h
right
intro b hb
obtain ⟨c, h | h⟩ := PreValuationRing.cond a b
· rw [← h]
exact Ideal.mul_mem_right _ _ h₁
· exfalso; apply h₂; rw [← h]
apply Ideal.mul_mem_right _ _ hb | instance | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | le_total_ideal | null |
_root_.PreValuationRing.iff_dvd_total [Semigroup R] :
PreValuationRing R ↔ IsTotal R (· ∣ ·) := by
classical
refine ⟨fun H => ⟨fun a b => ?_⟩, fun H => ⟨fun a b => ?_⟩⟩
· obtain ⟨c, rfl | rfl⟩ := PreValuationRing.cond a b <;> simp
· obtain ⟨c, rfl⟩ | ⟨c, rfl⟩ := @IsTotal.total _ _ H a b <;> use c <;> simp | theorem | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | _root_.PreValuationRing.iff_dvd_total | null |
_root_.PreValuationRing.iff_ideal_total [CommRing R] :
PreValuationRing R ↔ IsTotal (Ideal R) (· ≤ ·) := by
classical
refine ⟨fun _ => ⟨le_total⟩, fun H => PreValuationRing.iff_dvd_total.mpr ⟨fun a b => ?_⟩⟩
have := @IsTotal.total _ _ H (Ideal.span {a}) (Ideal.span {b})
simp_rw [Ideal.span_singleton_le_span_singleton] at this
exact this.symm
variable (K) | theorem | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | _root_.PreValuationRing.iff_ideal_total | null |
dvd_total [Semigroup R] [h : PreValuationRing R] (x y : R) : x ∣ y ∨ y ∣ x :=
@IsTotal.total _ _ (PreValuationRing.iff_dvd_total.mp h) x y | theorem | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | dvd_total | null |
iff_dvd_total : ValuationRing R ↔ IsTotal R (· ∣ ·) :=
Iff.trans (⟨fun inst ↦ inst.toPreValuationRing, fun _ ↦ .mk⟩)
PreValuationRing.iff_dvd_total | theorem | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | iff_dvd_total | null |
iff_ideal_total : ValuationRing R ↔ IsTotal (Ideal R) (· ≤ ·) :=
Iff.trans (⟨fun inst ↦ inst.toPreValuationRing, fun _ ↦ .mk⟩)
PreValuationRing.iff_ideal_total | theorem | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | iff_ideal_total | null |
unique_irreducible [PreValuationRing R] ⦃p q : R⦄ (hp : Irreducible p)
(hq : Irreducible q) : Associated p q := by
have := dvd_total p q
rw [Irreducible.dvd_comm hp hq, or_self_iff] at this
exact associated_of_dvd_dvd (Irreducible.dvd_symm hq hp this) this
variable (R) | theorem | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | unique_irreducible | null |
iff_isInteger_or_isInteger :
ValuationRing R ↔ ∀ x : K, IsLocalization.IsInteger R x ∨ IsLocalization.IsInteger R x⁻¹ := by
constructor
· intro H x
obtain ⟨x : R, y, hy, rfl⟩ := IsFractionRing.div_surjective (A := R) x
have := (map_ne_zero_iff _ (IsFractionRing.injective R K)).mpr (nonZeroDivisors.ne_zero hy)
obtain ⟨s, rfl | rfl⟩ := ValuationRing.cond x y
· exact Or.inr
⟨s, eq_inv_of_mul_eq_one_left <| by rwa [mul_div, div_eq_one_iff_eq, map_mul, mul_comm]⟩
· exact Or.inl ⟨s, by rwa [eq_div_iff, map_mul, mul_comm]⟩
· intro H
suffices PreValuationRing R from mk
constructor
intro a b
by_cases ha : a = 0; · subst ha; exact ⟨0, Or.inr <| mul_zero b⟩
by_cases hb : b = 0; · subst hb; exact ⟨0, Or.inl <| mul_zero a⟩
replace ha := (map_ne_zero_iff _ (IsFractionRing.injective R K)).mpr ha
replace hb := (map_ne_zero_iff _ (IsFractionRing.injective R K)).mpr hb
obtain ⟨c, e⟩ | ⟨c, e⟩ := H (algebraMap R K a / algebraMap R K b)
· rw [eq_div_iff hb, ← map_mul, (IsFractionRing.injective R K).eq_iff, mul_comm] at e
exact ⟨c, Or.inr e⟩
· rw [inv_div, eq_div_iff ha, ← map_mul, (IsFractionRing.injective R K).eq_iff, mul_comm c] at e
exact ⟨c, Or.inl e⟩
variable {K} | theorem | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | iff_isInteger_or_isInteger | null |
isInteger_or_isInteger [h : ValuationRing R] (x : K) :
IsLocalization.IsInteger R x ∨ IsLocalization.IsInteger R x⁻¹ :=
(iff_isInteger_or_isInteger R K).mp h x
variable {R} | theorem | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | isInteger_or_isInteger | null |
iff_local_bezout_domain : ValuationRing R ↔ IsLocalRing R ∧ IsBezout R :=
⟨fun _ ↦ ⟨inferInstance, inferInstance⟩, fun ⟨_, _⟩ ↦ inferInstance⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | iff_local_bezout_domain | null |
protected TFAE (R : Type u) [CommRing R] [IsDomain R] :
List.TFAE
[ValuationRing R,
∀ x : FractionRing R, IsLocalization.IsInteger R x ∨ IsLocalization.IsInteger R x⁻¹,
IsTotal R (· ∣ ·), IsTotal (Ideal R) (· ≤ ·), IsLocalRing R ∧ IsBezout R] := by
tfae_have 1 ↔ 2 := iff_isInteger_or_isInteger R _
tfae_have 1 ↔ 3 := iff_dvd_total
tfae_have 1 ↔ 4 := iff_ideal_total
tfae_have 1 ↔ 5 := iff_local_bezout_domain
tfae_finish | theorem | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | TFAE | null |
_root_.Function.Surjective.preValuationRing {R S : Type*} [Mul R] [PreValuationRing R]
[Mul S] (f : R →ₙ* S) (hf : Function.Surjective f) :
PreValuationRing S :=
⟨fun a b => by
obtain ⟨⟨a, rfl⟩, ⟨b, rfl⟩⟩ := hf a, hf b
obtain ⟨c, rfl | rfl⟩ := PreValuationRing.cond a b
exacts [⟨f c, Or.inl <| (map_mul _ _ _).symm⟩, ⟨f c, Or.inr <| (map_mul _ _ _).symm⟩]⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | _root_.Function.Surjective.preValuationRing | null |
_root_.Function.Surjective.valuationRing {R S : Type*} [NonAssocSemiring R]
[PreValuationRing R] [CommRing S] [IsDomain S] (f : R →+* S) (hf : Function.Surjective f) :
ValuationRing S :=
have : PreValuationRing S := Function.Surjective.preValuationRing (R := R) f hf
.mk | theorem | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | _root_.Function.Surjective.valuationRing | null |
_root_.isFractionRing_of_exists_eq_algebraMap_or_inv_eq_algebraMap_of_injective
(h : ∀ (x : K), ∃ a : 𝒪, x = algebraMap 𝒪 K a ∨ x⁻¹ = algebraMap 𝒪 K a)
(hinj : Function.Injective (algebraMap 𝒪 K)) :
IsFractionRing 𝒪 K := by
have : IsDomain 𝒪 := hinj.isDomain
constructor
· intro a
simpa using hinj.ne_iff.mpr (nonZeroDivisors.ne_zero a.2)
· intro x
obtain ⟨a, ha⟩ := h x
by_cases h0 : a = 0
· refine ⟨⟨0, 1⟩, by simpa [h0, eq_comm] using ha⟩
· have : algebraMap 𝒪 K a ≠ 0 := by simpa using hinj.ne_iff.mpr h0
rw [inv_eq_iff_eq_inv, ← one_div, eq_div_iff this] at ha
cases ha with
| inl ha => exact ⟨⟨a, 1⟩, by simpa⟩
| inr ha => exact ⟨⟨1, ⟨a, mem_nonZeroDivisors_of_ne_zero h0⟩⟩, by simpa using ha⟩
· intro _ _ hab
exact ⟨1, by simp only [OneMemClass.coe_one, hinj hab, one_mul]⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | _root_.isFractionRing_of_exists_eq_algebraMap_or_inv_eq_algebraMap_of_injective | null |
_root_.Valuation.Integers.isFractionRing {v : Valuation K Γ} (hv : v.Integers 𝒪) :
IsFractionRing 𝒪 K :=
isFractionRing_of_exists_eq_algebraMap_or_inv_eq_algebraMap_of_injective
hv.eq_algebraMap_or_inv_eq_algebraMap hv.hom_inj | lemma | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | _root_.Valuation.Integers.isFractionRing | null |
instIsFractionRingInteger (v : Valuation K Γ) : IsFractionRing v.integer K :=
(Valuation.integer.integers v).isFractionRing | instance | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | instIsFractionRingInteger | null |
of_integers (v : Valuation K Γ) (hh : v.Integers 𝒪) :
haveI := hh.hom_inj.isDomain
ValuationRing 𝒪 := by
haveI := hh.hom_inj.isDomain
suffices PreValuationRing 𝒪 from .mk
constructor
intro a b
rcases le_total (v (algebraMap 𝒪 K a)) (v (algebraMap 𝒪 K b)) with h | h
· obtain ⟨c, hc⟩ := Valuation.Integers.dvd_of_le hh h
use c; exact Or.inr hc.symm
· obtain ⟨c, hc⟩ := Valuation.Integers.dvd_of_le hh h
use c; exact Or.inl hc.symm | theorem | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | of_integers | If `𝒪` satisfies `v.integers 𝒪` where `v` is a valuation on a field, then `𝒪`
is a valuation ring. |
instValuationRingInteger (v : Valuation K Γ) : ValuationRing v.integer :=
of_integers (v := v) (Valuation.integer.integers v) | instance | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | instValuationRingInteger | null |
isFractionRing_iff [IsDomain 𝒪] [ValuationRing 𝒪] :
IsFractionRing 𝒪 K ↔
(∀ (x : K), ∃ a : 𝒪, x = algebraMap 𝒪 K a ∨ x⁻¹ = algebraMap 𝒪 K a) ∧
Function.Injective (algebraMap 𝒪 K) := by
refine ⟨fun h ↦ ⟨fun x ↦ ?_, IsFractionRing.injective _ _⟩, fun h ↦ ?_⟩
· obtain (⟨a, e⟩ | ⟨a, e⟩) := isInteger_or_isInteger 𝒪 x
exacts [⟨a, .inl e.symm⟩, ⟨a, .inr e.symm⟩]
· exact isFractionRing_of_exists_eq_algebraMap_or_inv_eq_algebraMap_of_injective h.1 h.2 | theorem | RingTheory | [
"Mathlib.RingTheory.Bezout",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.Localization.FractionRing",
"Mathlib.RingTheory.Localization.Integer",
"Mathlib.RingTheory.Valuation.Integers",
"Mathlib.Tactic.LinearCombination",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/Valuation/ValuationRing.lean | isFractionRing_iff | null |
ValuationSubring extends Subring K where
mem_or_inv_mem' : ∀ x : K, x ∈ carrier ∨ x⁻¹ ∈ carrier | structure | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationRing",
"Mathlib.RingTheory.Localization.AsSubring",
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.Ring.Subring.Pointwise",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.RingTheory.LocalRing.ResidueField.Basic"
] | Mathlib/RingTheory/Valuation/ValuationSubring.lean | ValuationSubring | A valuation subring of a field `K` is a subring `A` such that for every `x : K`,
either `x ∈ A` or `x⁻¹ ∈ A`.
This is equivalent to being maximal in the domination order
of local subrings (the stacks project definition). See `LocalSubring.isMax_iff`. |
mem_carrier (x : K) : x ∈ A.carrier ↔ x ∈ A := Iff.refl _
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationRing",
"Mathlib.RingTheory.Localization.AsSubring",
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.Ring.Subring.Pointwise",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.RingTheory.LocalRing.ResidueField.Basic"
] | Mathlib/RingTheory/Valuation/ValuationSubring.lean | mem_carrier | null |
mem_toSubring (x : K) : x ∈ A.toSubring ↔ x ∈ A := Iff.refl _
@[ext] | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationRing",
"Mathlib.RingTheory.Localization.AsSubring",
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.Ring.Subring.Pointwise",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.RingTheory.LocalRing.ResidueField.Basic"
] | Mathlib/RingTheory/Valuation/ValuationSubring.lean | mem_toSubring | null |
ext (A B : ValuationSubring K) (h : ∀ x, x ∈ A ↔ x ∈ B) : A = B := SetLike.ext h | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationRing",
"Mathlib.RingTheory.Localization.AsSubring",
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.Ring.Subring.Pointwise",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.RingTheory.LocalRing.ResidueField.Basic"
] | Mathlib/RingTheory/Valuation/ValuationSubring.lean | ext | null |
zero_mem : (0 : K) ∈ A := A.toSubring.zero_mem | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationRing",
"Mathlib.RingTheory.Localization.AsSubring",
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.Ring.Subring.Pointwise",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.RingTheory.LocalRing.ResidueField.Basic"
] | Mathlib/RingTheory/Valuation/ValuationSubring.lean | zero_mem | null |
one_mem : (1 : K) ∈ A := A.toSubring.one_mem | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationRing",
"Mathlib.RingTheory.Localization.AsSubring",
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.Ring.Subring.Pointwise",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.RingTheory.LocalRing.ResidueField.Basic"
] | Mathlib/RingTheory/Valuation/ValuationSubring.lean | one_mem | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.