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 ⌀ |
|---|---|---|---|---|---|---|
zpowers_eq_valueGroup (hπ : v.IsUniformizer π) :
valueGroup v = zpowers (Units.mk0 (v π) hπ.val_ne_zero) := by
rw [← (valueGroup v).genLTOne_zpowers_eq_top]
congr
simp only [val, Units.mk0_val, hπ]
exact IsRankOneDiscrete.valueGroup_genLTOne_eq_generator v | lemma | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Range",
"Mathlib.Algebra.Order.Group.Cyclic",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DiscreteValuationRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomainOfPrime"
] | Mathlib/RingTheory/Valuation/Discrete/Basic.lean | zpowers_eq_valueGroup | null |
@[ext]
Uniformizer where
/-- The integer underlying a `Uniformizer` -/
val : v.integer
valuation_gt_one : v.IsUniformizer val | structure | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Range",
"Mathlib.Algebra.Order.Group.Cyclic",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DiscreteValuationRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomainOfPrime"
] | Mathlib/RingTheory/Valuation/Discrete/Basic.lean | Uniformizer | The structure `Uniformizer` bundles together the term in the ring and a proof that it is a
uniformizer. |
mk' {x : A} (hx : v.IsUniformizer x) : v.Uniformizer where
val := ⟨x, le_of_lt hx.val_lt_one⟩
valuation_gt_one := hx
@[simp] | def | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Range",
"Mathlib.Algebra.Order.Group.Cyclic",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DiscreteValuationRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomainOfPrime"
] | Mathlib/RingTheory/Valuation/Discrete/Basic.lean | mk' | A constructor for `Uniformizer`. |
ne_zero (π : Uniformizer v) : π.1.1 ≠ 0 := π.2.ne_zero | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Range",
"Mathlib.Algebra.Order.Group.Cyclic",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DiscreteValuationRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomainOfPrime"
] | Mathlib/RingTheory/Valuation/Discrete/Basic.lean | ne_zero | null |
IsUniformizer.not_isUnit {π : v.integer} (hπ : IsUniformizer v π) : ¬ IsUnit π :=
fun h ↦ ne_of_gt hπ.val_lt_one (Integers.one_of_isUnit (integer.integers v) h).symm | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Range",
"Mathlib.Algebra.Order.Group.Cyclic",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DiscreteValuationRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomainOfPrime"
] | Mathlib/RingTheory/Valuation/Discrete/Basic.lean | IsUniformizer.not_isUnit | null |
IsRankOneDiscrete.mk' : IsRankOneDiscrete v :=
⟨(valueGroup v).genLTOne,
⟨(valueGroup v).genLTOne_zpowers_eq_top, (valueGroup v).genLTOne_lt_one⟩⟩ | instance | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Range",
"Mathlib.Algebra.Order.Group.Cyclic",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DiscreteValuationRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomainOfPrime"
] | Mathlib/RingTheory/Valuation/Discrete/Basic.lean | IsRankOneDiscrete.mk' | null |
exists_isUniformizer_of_isCyclic_of_nontrivial : ∃ π : K₀, IsUniformizer v (π : K) := by
simp only [IsUniformizer.iff, Subtype.exists, mem_valuationSubring_iff, exists_prop]
set g := (valueGroup v).genLTOne with hg
obtain ⟨⟨π, hπ⟩, hγ0⟩ : g.1 ∈ ((range v) \ {0}) := by
rw [← valueGroup_eq_range, hg]
exact ... | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Range",
"Mathlib.Algebra.Order.Group.Cyclic",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DiscreteValuationRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomainOfPrime"
] | Mathlib/RingTheory/Valuation/Discrete/Basic.lean | exists_isUniformizer_of_isCyclic_of_nontrivial | null |
IsUniformizer.of_associated {π₁ π₂ : K₀} (h1 : IsUniformizer v π₁)
(H : Associated π₁ π₂) : IsUniformizer v π₂ := by
obtain ⟨u, hu⟩ := H
have : v (u.1 : K) = 1 := (Integers.isUnit_iff_valuation_eq_one <|integer.integers v).mp u.isUnit
rwa [IsUniformizer.iff, ← hu, Subring.coe_mul, map_mul, this, mul_one, ← Is... | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Range",
"Mathlib.Algebra.Order.Group.Cyclic",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DiscreteValuationRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomainOfPrime"
] | Mathlib/RingTheory/Valuation/Discrete/Basic.lean | IsUniformizer.of_associated | An element associated to a uniformizer is itself a uniformizer. |
associated_of_isUniformizer {π₁ π₂ : K₀} (h1 : IsUniformizer v π₁)
(h2 : IsUniformizer v π₂) : Associated π₁ π₂ := by
have hval : v ((π₁ : K)⁻¹ * π₂) = 1 := by
simp [IsUniformizer.iff.mp h1, IsUniformizer.iff.mp h2]
set p : v.integer := ⟨(π₁.1 : K)⁻¹ * π₂.1, (v.mem_integer_iff _).mpr (le_of_eq hval)⟩ with h... | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Range",
"Mathlib.Algebra.Order.Group.Cyclic",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DiscreteValuationRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomainOfPrime"
] | Mathlib/RingTheory/Valuation/Discrete/Basic.lean | associated_of_isUniformizer | If two elements of `K₀` are uniformizers, then they are associated. |
exists_pow_Uniformizer {r : K₀} (hr : r ≠ 0) (π : Uniformizer v) :
∃ n : ℕ, ∃ u : K₀ˣ, r = (π.1 ^ n).1 * u.1 := by
have hr₀ : v r ≠ 0 := by rw [ne_eq, zero_iff, Subring.coe_eq_zero_iff]; exact hr
set vr : Γˣ := Units.mk0 (v r) hr₀ with hvr_def
have hvr : vr ∈ (valueGroup v) := by
apply mem_valueGroup
... | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Range",
"Mathlib.Algebra.Order.Group.Cyclic",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DiscreteValuationRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomainOfPrime"
] | Mathlib/RingTheory/Valuation/Discrete/Basic.lean | exists_pow_Uniformizer | null |
Uniformizer.is_generator (π : Uniformizer v) :
maximalIdeal v.valuationSubring = Ideal.span {π.1} := by
apply (maximalIdeal.isMaximal _).eq_of_le
· intro h
rw [Ideal.span_singleton_eq_top] at h
apply π.2.not_isUnit h
· intro x hx
by_cases hx₀ : x = 0
· simp [hx₀]
· obtain ⟨n, ⟨u, hu⟩⟩ := e... | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Range",
"Mathlib.Algebra.Order.Group.Cyclic",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DiscreteValuationRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomainOfPrime"
] | Mathlib/RingTheory/Valuation/Discrete/Basic.lean | Uniformizer.is_generator | null |
IsUniformizer.is_generator {π : v.valuationSubring} (hπ : IsUniformizer v π) :
maximalIdeal v.valuationSubring = Ideal.span {π} :=
Uniformizer.is_generator ⟨π, hπ⟩ | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Range",
"Mathlib.Algebra.Order.Group.Cyclic",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DiscreteValuationRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomainOfPrime"
] | Mathlib/RingTheory/Valuation/Discrete/Basic.lean | IsUniformizer.is_generator | null |
pow_Uniformizer_is_pow_generator (π : Uniformizer v) (n : ℕ) :
maximalIdeal v.valuationSubring ^ n = Ideal.span {π.1 ^ n} := by
rw [← Ideal.span_singleton_pow, Uniformizer.is_generator] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Range",
"Mathlib.Algebra.Order.Group.Cyclic",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DiscreteValuationRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomainOfPrime"
] | Mathlib/RingTheory/Valuation/Discrete/Basic.lean | pow_Uniformizer_is_pow_generator | null |
valuationSubring_not_isField [Nontrivial ↥(valueGroup v)] [IsCyclic (valueGroup v)] :
¬ IsField K₀ := by
obtain ⟨π, hπ⟩ := exists_isUniformizer_of_isCyclic_of_nontrivial v
rintro ⟨-, -, h⟩
have := hπ.ne_zero
simp only [ne_eq, Subring.coe_eq_zero_iff] at this
specialize h this
rw [← isUnit_iff_exists_inv... | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Range",
"Mathlib.Algebra.Order.Group.Cyclic",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DiscreteValuationRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomainOfPrime"
] | Mathlib/RingTheory/Valuation/Discrete/Basic.lean | valuationSubring_not_isField | null |
isUniformizer_of_maximalIdeal_eq_span [v.IsRankOneDiscrete] {r : K₀}
(hr : maximalIdeal v.valuationSubring = Ideal.span {r}) :
IsUniformizer v r := by
have hr₀ : r ≠ 0 := by
intro h
rw [h, Set.singleton_zero, span_zero] at hr
exact Ring.ne_bot_of_isMaximal_of_not_isField (maximalIdeal.isMaximal v.... | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Range",
"Mathlib.Algebra.Order.Group.Cyclic",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DiscreteValuationRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomainOfPrime"
] | Mathlib/RingTheory/Valuation/Discrete/Basic.lean | isUniformizer_of_maximalIdeal_eq_span | null |
ideal_isPrincipal [IsCyclic (valueGroup v)] [Nontrivial (valueGroup v)] (I : Ideal K₀) :
I.IsPrincipal := by
suffices ∀ P : Ideal K₀, P.IsPrime → Submodule.IsPrincipal P by
exact (IsPrincipalIdealRing.of_prime this).principal I
intro P hP
by_cases h_ne_bot : P = ⊥
· rw [h_ne_bot]; exact bot_isPrincipal
... | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Range",
"Mathlib.Algebra.Order.Group.Cyclic",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DiscreteValuationRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomainOfPrime"
] | Mathlib/RingTheory/Valuation/Discrete/Basic.lean | ideal_isPrincipal | null |
valuationSubring_isPrincipalIdealRing [IsCyclic (valueGroup v)]
[Nontrivial (valueGroup v)] : IsPrincipalIdealRing K₀ := ⟨fun I ↦ ideal_isPrincipal v I⟩ | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Range",
"Mathlib.Algebra.Order.Group.Cyclic",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DiscreteValuationRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomainOfPrime"
] | Mathlib/RingTheory/Valuation/Discrete/Basic.lean | valuationSubring_isPrincipalIdealRing | null |
valuationSubring_isDiscreteValuationRing [IsCyclic (valueGroup v)]
[Nontrivial (valueGroup v)] : IsDiscreteValuationRing K₀ where
toIsPrincipalIdealRing := valuationSubring_isPrincipalIdealRing v
toIsLocalRing := inferInstance
not_a_field' := by rw [ne_eq, ← isField_iff_maximalIdeal_eq]; exact valuationSubrin... | instance | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Range",
"Mathlib.Algebra.Order.Group.Cyclic",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DiscreteValuationRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomainOfPrime"
] | Mathlib/RingTheory/Valuation/Discrete/Basic.lean | valuationSubring_isDiscreteValuationRing | This is Chapter I, Section 1, Proposition 1 in Serre's Local Fields |
maximalIdeal : HeightOneSpectrum A where
asIdeal := IsLocalRing.maximalIdeal A
isPrime := Ideal.IsMaximal.isPrime (maximalIdeal.isMaximal A)
ne_bot := by simpa [ne_eq, ← isField_iff_maximalIdeal_eq] using not_isField A | def | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Range",
"Mathlib.Algebra.Order.Group.Cyclic",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DiscreteValuationRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomainOfPrime"
] | Mathlib/RingTheory/Valuation/Discrete/Basic.lean | maximalIdeal | The maximal ideal of a discrete valuation ring. |
isRankOneDiscrete :
IsRankOneDiscrete ((maximalIdeal A).valuation K) := by
have : Nontrivial ↥(valueGroup (valuation K (maximalIdeal A))) := by
let v := (maximalIdeal A).valuation K
let π := valuation_exists_uniformizer K (maximalIdeal A)|>.choose
have hπ : v π = ↑(ofAdd (-1 : ℤ)) :=
valuation_e... | instance | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Range",
"Mathlib.Algebra.Order.Group.Cyclic",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DiscreteValuationRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomainOfPrime"
] | Mathlib/RingTheory/Valuation/Discrete/Basic.lean | isRankOneDiscrete | null |
exists_lift_of_le_one {x : K} (H : ((maximalIdeal A).valuation K) x ≤ (1 : ℤᵐ⁰)) :
∃ a : A, algebraMap A K a = x := by
obtain ⟨π, hπ⟩ := exists_irreducible A
obtain ⟨a, b, hb, h_frac⟩ := IsFractionRing.div_surjective (A := A) x
by_cases ha : a = 0
· rw [← h_frac]
use 0
rw [ha, map_zero, zero_div]
... | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Range",
"Mathlib.Algebra.Order.Group.Cyclic",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DiscreteValuationRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomainOfPrime"
] | Mathlib/RingTheory/Valuation/Discrete/Basic.lean | exists_lift_of_le_one | null |
map_algebraMap_eq_valuationSubring : Subring.map (algebraMap A K) ⊤ =
((maximalIdeal A).valuation K).valuationSubring.toSubring := by
ext
refine ⟨fun h ↦ ?_, fun h ↦ ?_⟩
· obtain ⟨_, _, rfl⟩ := Subring.mem_map.mp h
apply valuation_le_one
· obtain ⟨y, rfl⟩ := exists_lift_of_le_one h
rw [Subring.mem_m... | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Range",
"Mathlib.Algebra.Order.Group.Cyclic",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DiscreteValuationRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomainOfPrime"
] | Mathlib/RingTheory/Valuation/Discrete/Basic.lean | map_algebraMap_eq_valuationSubring | null |
noncomputable equivValuationSubring :
A ≃+* ((maximalIdeal A).valuation K).valuationSubring :=
(topEquiv.symm.trans (equivMapOfInjective ⊤ (algebraMap A K)
(IsFractionRing.injective A _))).trans
(RingEquiv.subringCongr map_algebraMap_eq_valuationSubring) | def | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Range",
"Mathlib.Algebra.Order.Group.Cyclic",
"Mathlib.RingTheory.DedekindDomain.AdicValuation",
"Mathlib.RingTheory.DiscreteValuationRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomainOfPrime"
] | Mathlib/RingTheory/Valuation/Discrete/Basic.lean | equivValuationSubring | The ring isomorphism between a DVR `A` and the valuation subring of a field of fractions
of `A` endowed with the adic valuation of the maximal ideal. |
@[ext]
ValuativeRel (R : Type*) [CommRing R] where
/-- The relation operator arising from `ValuativeRel`. -/
rel : R → R → Prop
rel_total (x y) : rel x y ∨ rel y x
rel_trans {z y x} : rel x y → rel y z → rel x z
rel_add {x y z} : rel x z → rel y z → rel (x + y) z
rel_mul_right {x y} (z) : rel x y → rel (x *... | class | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValuativeRel | The class `[ValuativeRel R]` class introduces an operator `x ≤ᵥ y : Prop` for `x y : R`
which is the natural relation arising from (the equivalence class of) a valuation on `R`.
More precisely, if v is a valuation on R then the associated relation is `x ≤ᵥ y ↔ v x ≤ v y`.
Use this class to talk about the case where `R`... |
Compatible [ValuativeRel R] where
rel_iff_le (x y : R) : x ≤ᵥ y ↔ v x ≤ v y | class | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | Compatible | We say that a valuation `v` is `Compatible` if the relation `x ≤ᵥ y`
is equivalent to `v x ≤ x y`. |
ValuativePreorder (R : Type*) [CommRing R] [ValuativeRel R] [Preorder R] where
rel_iff_le (x y : R) : x ≤ᵥ y ↔ x ≤ y | class | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValuativePreorder | A preorder on a ring is said to be "valuative" if it agrees with the
valuative relation. |
@[simp]
rel_refl (x : R) : x ≤ᵥ x := by
cases rel_total x x <;> assumption | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | rel_refl | null |
rel_rfl {x : R} : x ≤ᵥ x :=
rel_refl x
protected alias rel.refl := rel_refl
protected alias rel.rfl := rel_rfl
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | rel_rfl | null |
zero_rel (x : R) : 0 ≤ᵥ x := by
simpa using rel_mul_right x ((rel_total 0 1).resolve_right not_rel_one_zero) | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | zero_rel | null |
rel_mul_left {x y : R} (z) : x ≤ᵥ y → (z * x) ≤ᵥ (z * y) := by
rw [mul_comm z x, mul_comm z y]
apply rel_mul_right | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | rel_mul_left | null |
rel_trans' {x y z : R} (h1 : y ≤ᵥ z) (h2 : x ≤ᵥ y) : x ≤ᵥ z :=
h2.trans h1
protected alias rel.trans' := rel_trans' | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | rel_trans' | null |
rel_mul {x x' y y' : R} (h1 : x ≤ᵥ y) (h2 : x' ≤ᵥ y') : (x * x') ≤ᵥ y * y' := by
calc x * x' ≤ᵥ x * y' := rel_mul_left _ h2
_ ≤ᵥ y * y' := rel_mul_right _ h1 | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | rel_mul | null |
rel_add_cases (x y : R) : x + y ≤ᵥ x ∨ x + y ≤ᵥ y :=
(rel_total y x).imp (fun h => rel_add .rfl h) (fun h => rel_add h .rfl)
variable (R) in | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | rel_add_cases | null |
posSubmonoid : Submonoid R where
carrier := { x | ¬ x ≤ᵥ 0}
mul_mem' {x y} hx hy := by
dsimp only [Set.mem_setOf_eq] at hx hy ⊢
contrapose! hy
rw [show (0 : R) = x * 0 by simp, mul_comm x y, mul_comm x 0] at hy
exact rel_mul_cancel hx hy
one_mem' := not_rel_one_zero
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | posSubmonoid | The submonoid of elements `x : R` whose valuation is positive. |
posSubmonoid_def (x : R) : x ∈ posSubmonoid R ↔ ¬ x ≤ᵥ 0 := Iff.refl _
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | posSubmonoid_def | null |
right_cancel_posSubmonoid (x y : R) (u : posSubmonoid R) :
x * u ≤ᵥ y * u ↔ x ≤ᵥ y := ⟨rel_mul_cancel u.prop, rel_mul_right _⟩
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | right_cancel_posSubmonoid | null |
left_cancel_posSubmonoid (x y : R) (u : posSubmonoid R) :
u * x ≤ᵥ u * y ↔ x ≤ᵥ y := by
simp only [← right_cancel_posSubmonoid x y u, mul_comm]
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | left_cancel_posSubmonoid | null |
val_posSubmonoid_ne_zero (x : posSubmonoid R) :
(x : R) ≠ 0 := by
have := x.prop
rw [posSubmonoid_def] at this
contrapose! this
simp [this]
variable (R) in | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | val_posSubmonoid_ne_zero | null |
valueSetoid : Setoid (R × posSubmonoid R) where
r := fun (x, s) (y, t) => x * t ≤ᵥ y * s ∧ y * s ≤ᵥ x * t
iseqv := {
refl ru := ⟨rel_refl _, rel_refl _⟩
symm h := ⟨h.2, h.1⟩
trans := by
rintro ⟨r, u⟩ ⟨s, v⟩ ⟨t, w⟩ ⟨h1, h2⟩ ⟨h3, h4⟩
constructor
· have := rel_mul h1 (rel_refl ↑w)
... | def | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | valueSetoid | The setoid used to construct `ValueGroupWithZero R`. |
ValueGroupWithZero := Quotient (valueSetoid R) | def | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero | The "canonical" value group-with-zero of a ring with a valuative relation. |
protected
ValueGroupWithZero.mk (x : R) (y : posSubmonoid R) : ValueGroupWithZero R :=
Quotient.mk _ (x, y) | def | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.mk | Construct an element of the value group-with-zero from an element `r : R` and
`y : posSubmonoid R`. This should be thought of as `v r / v y`. |
protected
ValueGroupWithZero.sound {x y : R} {t s : posSubmonoid R}
(h₁ : x * s ≤ᵥ y * t) (h₂ : y * t ≤ᵥ x * s) :
ValueGroupWithZero.mk x t = ValueGroupWithZero.mk y s :=
Quotient.sound ⟨h₁, h₂⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.sound | null |
protected
ValueGroupWithZero.exact {x y : R} {t s : posSubmonoid R}
(h : ValueGroupWithZero.mk x t = ValueGroupWithZero.mk y s) :
x * s ≤ᵥ y * t ∧ y * t ≤ᵥ x * s :=
Quotient.exact h | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.exact | null |
protected
ValueGroupWithZero.ind {motive : ValueGroupWithZero R → Prop} (mk : ∀ x y, motive (.mk x y))
(t : ValueGroupWithZero R) : motive t :=
Quotient.ind (fun (x, y) => mk x y) t | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.ind | null |
protected
ValueGroupWithZero.lift {α : Sort*} (f : R → posSubmonoid R → α)
(hf : ∀ (x y : R) (t s : posSubmonoid R), x * t ≤ᵥ y * s → y * s ≤ᵥ x * t → f x s = f y t)
(t : ValueGroupWithZero R) : α :=
Quotient.lift (fun (x, y) => f x y) (fun (x, t) (y, s) ⟨h₁, h₂⟩ => hf x y s t h₁ h₂) t
@[simp] protected | def | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.lift | Lifts a function `R → posSubmonoid R → α` to the value group-with-zero of `R`. |
ValueGroupWithZero.lift_mk {α : Sort*} (f : R → posSubmonoid R → α)
(hf : ∀ (x y : R) (t s : posSubmonoid R), x * t ≤ᵥ y * s → y * s ≤ᵥ x * t → f x s = f y t)
(x : R) (y : posSubmonoid R) : ValueGroupWithZero.lift f hf (.mk x y) = f x y := rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.lift_mk | null |
protected
ValueGroupWithZero.lift₂ {α : Sort*} (f : R → posSubmonoid R → R → posSubmonoid R → α)
(hf : ∀ (x y z w : R) (t s u v : posSubmonoid R),
x * t ≤ᵥ y * s → y * s ≤ᵥ x * t → z * u ≤ᵥ w * v → w * v ≤ᵥ z * u →
f x s z v = f y t w u)
(t₁ : ValueGroupWithZero R) (t₂ : ValueGroupWithZero R) : α :=... | def | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.lift₂ | Lifts a function `R → posSubmonoid R → R → posSubmonoid R → α` to
the value group-with-zero of `R`. |
ValueGroupWithZero.lift₂_mk {α : Sort*} (f : R → posSubmonoid R → R → posSubmonoid R → α)
(hf : ∀ (x y z w : R) (t s u v : posSubmonoid R),
x * t ≤ᵥ y * s → y * s ≤ᵥ x * t → z * u ≤ᵥ w * v → w * v ≤ᵥ z * u →
f x s z v = f y t w u)
(x y : R) (z w : posSubmonoid R) :
ValueGroupWithZero.lift₂ f hf ... | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.lift₂_mk | null |
ValueGroupWithZero.mk_eq_mk {x y : R} {t s : posSubmonoid R} :
ValueGroupWithZero.mk x t = ValueGroupWithZero.mk y s ↔ x * s ≤ᵥ y * t ∧ y * t ≤ᵥ x * s :=
Quotient.eq | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.mk_eq_mk | null |
@[simp]
ValueGroupWithZero.mk_eq_zero (x : R) (y : posSubmonoid R) :
ValueGroupWithZero.mk x y = 0 ↔ x ≤ᵥ 0 :=
⟨fun h => by simpa using ValueGroupWithZero.mk_eq_mk.mp h,
fun h => ValueGroupWithZero.sound (by simpa using h) (by simp)⟩
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.mk_eq_zero | null |
ValueGroupWithZero.mk_zero (x : posSubmonoid R) : ValueGroupWithZero.mk 0 x = 0 :=
(ValueGroupWithZero.mk_eq_zero 0 x).mpr .rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.mk_zero | null |
@[simp]
ValueGroupWithZero.mk_self (x : posSubmonoid R) : ValueGroupWithZero.mk (x : R) x = 1 :=
ValueGroupWithZero.sound (by simp) (by simp)
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.mk_self | null |
ValueGroupWithZero.mk_one_one : ValueGroupWithZero.mk (1 : R) 1 = 1 :=
ValueGroupWithZero.sound (by simp) (by simp)
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.mk_one_one | null |
ValueGroupWithZero.mk_eq_one (x : R) (y : posSubmonoid R) :
ValueGroupWithZero.mk x y = 1 ↔ x ≤ᵥ y ∧ y ≤ᵥ x := by
simp [← mk_one_one, mk_eq_mk] | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.mk_eq_one | null |
ValueGroupWithZero.lift_zero {α : Sort*} (f : R → posSubmonoid R → α)
(hf : ∀ (x y : R) (t s : posSubmonoid R), x * t ≤ᵥ y * s → y * s ≤ᵥ x * t → f x s = f y t) :
ValueGroupWithZero.lift f hf 0 = f 0 1 :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.lift_zero | null |
ValueGroupWithZero.lift_one {α : Sort*} (f : R → posSubmonoid R → α)
(hf : ∀ (x y : R) (t s : posSubmonoid R), x * t ≤ᵥ y * s → y * s ≤ᵥ x * t → f x s = f y t) :
ValueGroupWithZero.lift f hf 1 = f 1 1 :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.lift_one | null |
@[simp]
ValueGroupWithZero.mk_mul_mk (a b : R) (c d : posSubmonoid R) :
ValueGroupWithZero.mk a c * ValueGroupWithZero.mk b d = ValueGroupWithZero.mk (a * b) (c * d) :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.mk_mul_mk | null |
ValueGroupWithZero.lift_mul {α : Type*} [Mul α] (f : R → posSubmonoid R → α)
(hf : ∀ (x y : R) (t s : posSubmonoid R), x * t ≤ᵥ y * s → y * s ≤ᵥ x * t → f x s = f y t)
(hdist : ∀ (a b r s), f (a * b) (r * s) = f a r * f b s)
(a b : ValueGroupWithZero R) :
ValueGroupWithZero.lift f hf (a * b) =
Val... | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.lift_mul | null |
@[simp]
ValueGroupWithZero.mk_le_mk (x y : R) (t s : posSubmonoid R) :
ValueGroupWithZero.mk x t ≤ ValueGroupWithZero.mk y s ↔ x * s ≤ᵥ y * t := Iff.rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.mk_le_mk | null |
@[simp]
ValueGroupWithZero.mk_lt_mk (x y : R) (t s : posSubmonoid R) :
ValueGroupWithZero.mk x t < ValueGroupWithZero.mk y s ↔
x * s ≤ᵥ y * t ∧ ¬ y * t ≤ᵥ x * s :=
Iff.rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.mk_lt_mk | null |
ValueGroupWithZero.bot_eq_zero : (⊥ : ValueGroupWithZero R) = 0 := rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.bot_eq_zero | null |
@[simp]
ValueGroupWithZero.inv_mk (x : R) (y : posSubmonoid R) (hx : ¬x ≤ᵥ 0) :
(ValueGroupWithZero.mk x y)⁻¹ = ValueGroupWithZero.mk (y : R) ⟨x, hx⟩ := dif_neg hx | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.inv_mk | null |
valuation : Valuation R (ValueGroupWithZero R) where
toFun r := ValueGroupWithZero.mk r 1
map_zero' := rfl
map_one' := rfl
map_mul' _ _ := by simp
map_add_le_max' := by simp [rel_add_cases] | def | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | valuation | The value group-with-zero is a linearly ordered commutative group with zero. -/
instance : LinearOrderedCommGroupWithZero (ValueGroupWithZero R) where
zero_le_one := bot_le
exists_pair_ne := by
refine ⟨0, 1, fun h => ?_⟩
apply ge_of_eq at h
rw [← ValueGroupWithZero.mk_zero 1, ← ValueGroupWithZero.mk_one... |
@[simp]
ValueGroupWithZero.lift_valuation {α : Sort*} (f : R → posSubmonoid R → α)
(hf : ∀ (x y : R) (t s : posSubmonoid R), x * t ≤ᵥ y * s → y * s ≤ᵥ x * t → f x s = f y t)
(x : R) :
ValueGroupWithZero.lift f hf (valuation R x) = f x 1 :=
rfl | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.lift_valuation | null |
valuation_eq_zero_iff {x : R} :
valuation R x = 0 ↔ x ≤ᵥ 0 :=
ValueGroupWithZero.mk_eq_zero _ _ | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | valuation_eq_zero_iff | null |
valuation_posSubmonoid_ne_zero (x : posSubmonoid R) :
valuation R (x : R) ≠ 0 := by
rw [ne_eq, valuation_eq_zero_iff]
exact x.prop | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | valuation_posSubmonoid_ne_zero | null |
ValueGroupWithZero.mk_eq_div (r : R) (s : posSubmonoid R) :
ValueGroupWithZero.mk r s = valuation R r / valuation R (s : R) := by
rw [eq_div_iff (valuation_posSubmonoid_ne_zero _)]
simp [valuation, mk_eq_mk] | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.mk_eq_div | null |
ofValuation
{S Γ : Type*} [CommRing S]
[LinearOrderedCommGroupWithZero Γ]
(v : Valuation S Γ) : ValuativeRel S where
rel x y := v x ≤ v y
rel_total x y := le_total (v x) (v y)
rel_trans := le_trans
rel_add hab hbc := (map_add_le_max v _ _).trans (sup_le hab hbc)
rel_mul_right _ h := by simp only [... | def | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ofValuation | Construct a valuative relation on a ring using a valuation. |
_root_.Valuation.Compatible.ofValuation
{S Γ : Type*} [CommRing S]
[LinearOrderedCommGroupWithZero Γ]
(v : Valuation S Γ) :
letI := ValuativeRel.ofValuation v -- letI so that instance is inlined directly in declaration
Valuation.Compatible v :=
letI := ValuativeRel.ofValuation v
⟨fun _ _ ↦ Iff.... | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | _root_.Valuation.Compatible.ofValuation | null |
isEquiv {Γ₁ Γ₂ : Type*}
[LinearOrderedCommMonoidWithZero Γ₁]
[LinearOrderedCommMonoidWithZero Γ₂]
(v₁ : Valuation R Γ₁)
(v₂ : Valuation R Γ₂)
[v₁.Compatible] [v₂.Compatible] :
v₁.IsEquiv v₂ := by
intro x y
simp_rw [← Valuation.Compatible.rel_iff_le]
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | isEquiv | null |
_root_.Valuation.apply_posSubmonoid_ne_zero {Γ : Type*} [LinearOrderedCommMonoidWithZero Γ]
(v : Valuation R Γ) [v.Compatible] (x : posSubmonoid R) :
v (x : R) ≠ 0 := by
simp [(isEquiv v (valuation R)).ne_zero, valuation_posSubmonoid_ne_zero]
@[deprecated (since := "2025-08-06")]
alias valuation_posSubmonoid_... | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | _root_.Valuation.apply_posSubmonoid_ne_zero | null |
_root_.Valuation.apply_posSubmonoid_pos {Γ : Type*} [LinearOrderedCommMonoidWithZero Γ]
(v : Valuation R Γ) [v.Compatible] (x : posSubmonoid R) :
0 < v x :=
zero_lt_iff.mpr <| v.apply_posSubmonoid_ne_zero x
variable (R) in | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | _root_.Valuation.apply_posSubmonoid_pos | null |
WithPreorder := R | def | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | WithPreorder | An alias for endowing a ring with a preorder defined as the valuative relation. |
supp : Ideal R where
carrier := { x | x ≤ᵥ 0 }
add_mem' ha hb := rel_add ha hb
zero_mem' := rel_refl _
smul_mem' x _ h := by simpa using rel_mul_left _ h
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | supp | The ring instance on `WithPreorder R` arising from the ring structure on `R`. -/
instance : CommRing (WithPreorder R) := inferInstanceAs (CommRing R)
/-- The preorder on `WithPreorder R` arising from the valuative relation on `R`. -/
instance : Preorder (WithPreorder R) where
le (x y : R) := x ≤ᵥ y
le_refl _ := re... |
supp_def (x : R) : x ∈ supp R ↔ x ≤ᵥ 0 := Iff.refl _ | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | supp_def | null |
supp_eq_valuation_supp : supp R = (valuation R).supp := by
ext x
constructor
· intro h
simp only [supp_def, Valuation.mem_supp_iff] at h ⊢
apply ValueGroupWithZero.sound
· simpa
· simp
· intro h
have := ValueGroupWithZero.exact h
simpa using this.left | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | supp_eq_valuation_supp | null |
RankLeOneStruct where
/-- The embedding of the value group-with-zero into the nonnegative reals. -/
emb : ValueGroupWithZero R →*₀ ℝ≥0
strictMono : StrictMono emb
variable (R) in | structure | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | RankLeOneStruct | An auxiliary structure used to define `IsRankLeOne`. |
IsRankLeOne where
nonempty : Nonempty (RankLeOneStruct R)
variable (R) in | class | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | IsRankLeOne | We say that a ring with a valuative relation is of rank one if
there exists a strictly monotone embedding of the "canonical" value group-with-zero into
the nonnegative reals, and the image of this embedding contains some element different
from `0` and `1`. |
IsNontrivial where
condition : ∃ γ : ValueGroupWithZero R, γ ≠ 0 ∧ γ ≠ 1 | class | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | IsNontrivial | We say that a valuative relation on a ring is *nontrivial* if the
value group-with-zero is nontrivial, meaning that it has an element
which is different from 0 and 1. |
isNontrivial_iff_nontrivial_units :
IsNontrivial R ↔ Nontrivial (ValueGroupWithZero R)ˣ := by
constructor
· rintro ⟨γ, hγ, hγ'⟩
refine ⟨Units.mk0 _ hγ, 1, ?_⟩
simp [← Units.val_eq_one, hγ']
· rintro ⟨r, s, h⟩
rcases eq_or_ne r 1 with rfl | hr
· exact ⟨s.val, by simp, by simpa using h.symm⟩
... | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | isNontrivial_iff_nontrivial_units | null |
isNontrivial_iff_isNontrivial :
IsNontrivial R ↔ (valuation R).IsNontrivial := by
constructor
· rintro ⟨r, hr, hr'⟩
induction r using ValueGroupWithZero.ind with | mk r s
by_cases hs : valuation R s = 1
· refine ⟨r, ?_, ?_⟩
· simpa [valuation] using hr
· simp only [ne_eq, ValueGroupWithZ... | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | isNontrivial_iff_isNontrivial | null |
IsDiscrete where
has_maximal_element :
∃ γ : ValueGroupWithZero R, γ < 1 ∧ (∀ δ : ValueGroupWithZero R, δ < 1 → δ ≤ γ) | class | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | IsDiscrete | A ring with a valuative relation is discrete if its value group-with-zero
has a maximal element `< 1`. |
valuation_surjective (γ : ValueGroupWithZero R) :
∃ (a : R) (b : posSubmonoid R), valuation _ a / valuation _ (b : R) = γ := by
induction γ using ValueGroupWithZero.ind with | mk a b
use a, b
simp [valuation, div_eq_mul_inv, ValueGroupWithZero.inv_mk (b : R) 1 b.prop] | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | valuation_surjective | null |
exists_valuation_posSubmonoid_div_valuation_posSubmonoid_eq (γ : (ValueGroupWithZero R)ˣ) :
∃ (a b : posSubmonoid R), valuation R a / valuation _ (b : R) = γ := by
obtain ⟨a, b, hab⟩ := valuation_surjective γ.val
lift a to posSubmonoid R using by
rw [posSubmonoid_def, ← valuation_eq_zero_iff]
intro H
... | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | exists_valuation_posSubmonoid_div_valuation_posSubmonoid_eq | null |
IsValuativeTopology (R : Type*) [CommRing R] [ValuativeRel R] [TopologicalSpace R] where
mem_nhds_iff {s : Set R} {x : R} : s ∈ 𝓝 (x : R) ↔
∃ γ : (ValueGroupWithZero R)ˣ, (x + ·) '' { z | valuation _ z < γ } ⊆ s
@[deprecated (since := "2025-08-01")] alias ValuativeTopology := IsValuativeTopology | class | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | IsValuativeTopology | We say that a topology on `R` is valuative if the neighborhoods of `0` in `R`
are determined by the relation `· ≤ᵥ ·`. |
noncomputable
ValueGroupWithZero.embed [h : v.Compatible] : ValueGroupWithZero R →*₀ Γ where
toFun := ValuativeRel.ValueGroupWithZero.lift (fun r s ↦ v r / v (s : R)) <| by
intro x y r s
simp only [h.rel_iff_le, map_mul, ← and_imp, ← le_antisymm_iff]
rw [div_eq_div_iff] <;> simp
map_zero' := by simp [Va... | def | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.embed | Any valuation compatible with the valuative relation can be factored through
the value group. |
ValueGroupWithZero.embed_mk [v.Compatible] (x : R) (s : posSubmonoid R) :
embed v (.mk x s) = v x / v (s : R) :=
rfl
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.embed_mk | null |
ValueGroupWithZero.embed_valuation (γ : ValueGroupWithZero R) :
embed (valuation R) γ = γ := by
induction γ using ValueGroupWithZero.ind
simp [embed_mk, ← mk_eq_div] | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.embed_valuation | null |
ValueGroupWithZero.embed_strictMono [v.Compatible] : StrictMono (embed v) := by
intro a b h
obtain ⟨a, r, rfl⟩ := valuation_surjective a
obtain ⟨b, s, rfl⟩ := valuation_surjective b
simp only [map_div₀]
rw [div_lt_div_iff₀] at h ⊢
any_goals simp [zero_lt_iff]
rw [← map_mul, ← map_mul, (isEquiv (valuation ... | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValueGroupWithZero.embed_strictMono | null |
one_apply_posSubmonoid [Nontrivial R] [NoZeroDivisors R] [DecidablePred fun x : R ↦ x = 0]
(x : posSubmonoid R) : (1 : Valuation R Γ) x = 1 :=
Valuation.one_apply_of_ne_zero (by simp) | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | one_apply_posSubmonoid | For any `x ∈ posSubmonoid R`, the trivial valuation `1 : Valuation R Γ` sends `x` to `1`.
In fact, this is true for any `x ≠ 0`. This lemma is a special case useful for shorthand of
`x ∈ posSubmonoid R → x ≠ 0`. |
ValuativeExtension
(A B : Type*)
[CommRing A] [CommRing B]
[ValuativeRel A] [ValuativeRel B]
[Algebra A B] where
rel_iff_rel (a b : A) : algebraMap A B a ≤ᵥ algebraMap A B b ↔ a ≤ᵥ b | class | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | ValuativeExtension | If `B` is an `A` algebra and both `A` and `B` have valuative relations,
we say that `B|A` is a valuative extension if the valuative relation on `A` is
induced by the one on `B`. |
@[simps]
mapPosSubmonoid : posSubmonoid A →* posSubmonoid B where
toFun := fun ⟨a,ha⟩ => ⟨algebraMap _ _ a,
by simpa only [posSubmonoid_def, ← (algebraMap A B).map_zero, rel_iff_rel] using ha⟩
map_one' := by simp
map_mul' := by simp
variable (A) in | def | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | mapPosSubmonoid | The morphism of `posSubmonoid`s associated to an algebra map.
This is used in constructing `ValuativeExtension.mapValueGroupWithZero`. |
compatible_comap {Γ : Type*}
[LinearOrderedCommMonoidWithZero Γ] (w : Valuation B Γ) [w.Compatible] :
(w.comap (algebraMap A B)).Compatible := by
constructor
simp [← rel_iff_rel (A := A) (B := B), Valuation.Compatible.rel_iff_le (v := w)]
variable (A B) in | instance | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | compatible_comap | null |
mapValueGroupWithZero : ValueGroupWithZero A →*₀ ValueGroupWithZero B :=
have := compatible_comap A (valuation B)
ValueGroupWithZero.embed ((valuation B).comap (algebraMap A B))
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | mapValueGroupWithZero | The map on value groups-with-zero associated to the structure morphism of an algebra. |
mapValueGroupWithZero_mk (r : A) (s : posSubmonoid A) :
mapValueGroupWithZero A B (.mk r s) = .mk (algebraMap A B r) (mapPosSubmonoid A B s) := by
simp [mapValueGroupWithZero, ValueGroupWithZero.mk_eq_div (R := B)]
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | mapValueGroupWithZero_mk | null |
mapValueGroupWithZero_valuation (a : A) :
mapValueGroupWithZero A B (valuation _ a) = valuation _ (algebraMap _ _ a) := by
simp [valuation] | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic",
"Mathlib.Data.NNReal.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Basic.lean | mapValueGroupWithZero_valuation | null |
trivialRel : ValuativeRel R where
rel x y := if y = 0 then x = 0 else True
rel_total _ _ := by split_ifs <;> simp_all
rel_trans _ _ := by split_ifs; simp_all
rel_add _ _ := by split_ifs; simp_all
rel_mul_right _ := by split_ifs <;> simp_all
rel_mul_cancel _ := by split_ifs <;> simp_all
not_rel_one_zero :=... | def | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuativeRel.Basic"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Trivial.lean | trivialRel | The trivial valuative relation on a domain `R`, such that all non-zero elements are related.
The domain condition is necessary so that the relation is closed when multiplying. |
eq_trivialRel_of_compatible_one [h : ValuativeRel R]
[hv : Valuation.Compatible (1 : Valuation R Γ)] : h = trivialRel := by
ext
change _ ↔ if _ = 0 then _ else _
rw [hv.rel_iff_le]
split_ifs <;>
simp_all [Valuation.one_apply_of_ne_zero, Valuation.one_apply_le_one] | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuativeRel.Basic"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Trivial.lean | eq_trivialRel_of_compatible_one | null |
trivialRel_eq_ofValuation_one :
trivialRel = ValuativeRel.ofValuation (1 : Valuation R Γ) := by
convert (eq_trivialRel_of_compatible_one (Γ := Γ)).symm
exact Valuation.Compatible.ofValuation 1
variable (R Γ) in | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuativeRel.Basic"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Trivial.lean | trivialRel_eq_ofValuation_one | null |
subsingleton_units_valueGroupWithZero_of_trivialRel [ValuativeRel R]
[Valuation.Compatible (1 : Valuation R Γ)] :
Subsingleton (ValueGroupWithZero R)ˣ := by
constructor
intro a b
have : (valuation R).IsEquiv (1 : Valuation R Γ) := isEquiv _ _
obtain ⟨r, s, hr⟩ := exists_valuation_posSubmonoid_div_valuat... | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuativeRel.Basic"
] | Mathlib/RingTheory/Valuation/ValuativeRel/Trivial.lean | subsingleton_units_valueGroupWithZero_of_trivialRel | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.