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 mem_image_of_mem Units.val (valueGroup v).genLTOne_mem
use π
rw [hπ, hg]
exact ⟨le_of_lt (valueGroup v).genLTOne_lt_one, by rw [valueGroup_genLTOne_eq_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 | 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, ← IsUniformizer.iff] | 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 hp
use ((Integers.isUnit_iff_valuation_eq_one (x := p) <| integer.integers v).mpr hval).unit
apply_fun ((↑) : K₀ → K) using Subtype.val_injective
simp [hp, ← mul_assoc, mul_inv_cancel₀ h1.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 | 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
rw [hvr_def, Units.val_mk0 hr₀]
exact mem_range_self _
rw [π.2.zpowers_eq_valueGroup, mem_zpowers_iff] at hvr
obtain ⟨m, hm⟩ := hvr
have hm' : v π.val ^ m = v r := by
rw [hvr_def] at hm
rw [← Units.val_mk0 hr₀, ← hm]
simp [Units.val_zpow_eq_zpow_val, Units.val_mk0]
have hm₀ : 0 ≤ m := by
rw [← zpow_le_one_iff_right_of_lt_one₀ π.2.val_pos π.2.val_lt_one, hm']
exact r.2
obtain ⟨n, hn⟩ := Int.eq_ofNat_of_zero_le hm₀
use n
have hpow : v (π.1.1 ^ (-m) * r) = 1 := by
rw [map_mul, map_zpow₀, ← hm', zpow_neg, hm', inv_mul_cancel₀ hr₀]
set a : K₀ := ⟨π.1.1 ^ (-m) * r, by apply le_of_eq hpow⟩ with ha
have ha₀ : (↑a : K) ≠ 0 := by
simp only [zpow_neg, ne_eq, mul_eq_zero, inv_eq_zero, ZeroMemClass.coe_eq_zero, not_or, ha]
refine ⟨?_, hr⟩
rw [hn, zpow_natCast, pow_eq_zero_iff', not_and_or]
exact Or.inl π.ne_zero
have h_unit_a : IsUnit a :=
Integers.isUnit_of_one (integer.integers v) (isUnit_iff_ne_zero.mpr ha₀) hpow
use h_unit_a.unit
rw [IsUnit.unit_spec, Subring.coe_pow, ha, ← mul_assoc, zpow_neg, hn, zpow_natCast,
mul_inv_cancel₀ (pow_ne_zero _ π.ne_zero), one_mul] | 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⟩⟩ := exists_pow_Uniformizer hx₀ π
rw [← Subring.coe_mul, Subtype.coe_inj] at hu
have hn : Not (IsUnit x) := fun h ↦
(maximalIdeal.isMaximal _).ne_top (eq_top_of_isUnit_mem _ hx h)
replace hn : n ≠ 0 := fun h ↦ by
simp only [hu, h, pow_zero, one_mul, Units.isUnit, not_true] at hn
simp [Ideal.mem_span_singleton, hu, dvd_pow_self _ hn] | 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] at h
exact hπ.not_isUnit 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 | 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.valuationSubring)
(valuationSubring_not_isField v) hr
obtain ⟨π, hπ⟩ := exists_isUniformizer_of_isCyclic_of_nontrivial v
obtain ⟨n, u, hu⟩ := exists_pow_Uniformizer hr₀ ⟨π, hπ⟩
rw [Uniformizer.is_generator ⟨π, hπ⟩, span_singleton_eq_span_singleton] at hr
exact hπ.of_associated hr | 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
· let π : Uniformizer v := Nonempty.some (by infer_instance)
obtain ⟨x, ⟨hx_mem, hx₀⟩⟩ := Submodule.exists_mem_ne_zero_of_ne_bot h_ne_bot
obtain ⟨n, ⟨u, hu⟩⟩ := exists_pow_Uniformizer hx₀ π
by_cases hn : n = 0
· rw [← Subring.coe_mul, hn, pow_zero, one_mul, SetLike.coe_eq_coe] at hu
refine (hP.ne_top (Ideal.eq_top_of_isUnit_mem P hx_mem ?_)).elim
simp only [hu, Units.isUnit]
· rw [← Subring.coe_mul, SetLike.coe_eq_coe] at hu
rw [hu, Ideal.mul_unit_mem_iff_mem P u.isUnit,
IsPrime.pow_mem_iff_mem hP _ (pos_iff_ne_zero.mpr hn), ← Ideal.span_singleton_le_iff_mem,
← π.is_generator ] at hx_mem
rw [← Ideal.IsMaximal.eq_of_le (IsLocalRing.maximalIdeal.isMaximal K₀) hP.ne_top hx_mem]
exact ⟨π.1, π.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 | 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 valuationSubring_not_isField v | 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_exists_uniformizer K (maximalIdeal A)|>.choose_spec
rw [Subgroup.nontrivial_iff_exists_ne_one]
use Units.mk0 (v π) (by simp [hπ])
constructor
· apply mem_valueGroup
simp only [Units.val_mk0, Set.mem_range]
use π
· simpa [hπ] using not_eq_of_beq_eq_false rfl
infer_instance
variable {A K}
open scoped WithZero | 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]
· rw [← h_frac] at H
obtain ⟨n, u, rfl⟩ := eq_unit_mul_pow_irreducible ha hπ
obtain ⟨m, w, rfl⟩ := eq_unit_mul_pow_irreducible (nonZeroDivisors.ne_zero hb) hπ
replace hb := (mul_mem_nonZeroDivisors.mp hb).2
rw [mul_comm (w : A) _, map_mul _ (u : A) _, map_mul _ _ (w : A), div_eq_mul_inv, mul_assoc,
Valuation.map_mul, Integers.one_of_isUnit' u.isUnit (valuation_le_one _), one_mul,
mul_inv, ← mul_assoc, Valuation.map_mul, map_mul, map_inv₀, map_inv₀,
Integers.one_of_isUnit' w.isUnit (valuation_le_one _), inv_one, mul_one, ← div_eq_mul_inv,
← map_div₀, ← IsFractionRing.mk'_mk_eq_div hb,
valuation_of_mk', map_pow, map_pow] at H
have h_mn : m ≤ n := by
have v_π_lt_one := (intValuation_lt_one_iff_dvd (maximalIdeal A) π).mpr
(dvd_of_eq ((irreducible_iff_uniformizer _).mp hπ))
have v_π_ne_zero : (maximalIdeal A).intValuation π ≠ 0 := intValuation_ne_zero _ _ hπ.ne_zero
zify
rw [← WithZero.coe_one, div_eq_mul_inv, ← zpow_natCast, ← zpow_natCast, ← ofAdd_zero,
← zpow_neg, ← zpow_add₀ v_π_ne_zero, ← sub_eq_add_neg] at H
rwa [← sub_nonneg, ← zpow_le_one_iff_right_of_lt_one₀ (zero_lt_iff.mpr v_π_ne_zero)
v_π_lt_one]
use u * π ^ (n - m) * w.2
simp only [← h_frac, Units.inv_eq_val_inv, _root_.map_mul, _root_.map_pow, map_units_inv,
mul_assoc, mul_div_assoc ((algebraMap A _) ↑u) _ _]
congr 1
rw [div_eq_mul_inv, mul_inv, mul_comm ((algebraMap A _) ↑w)⁻¹ _, ←
mul_assoc _ _ ((algebraMap A _) ↑w)⁻¹]
congr
rw [pow_sub₀ _ _ h_mn]
apply IsFractionRing.to_map_ne_zero_of_mem_nonZeroDivisors
rw [mem_nonZeroDivisors_iff_ne_zero]
exact hπ.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 | 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_map]
exact ⟨y, mem_top _, rfl⟩ | 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 * z) (y * z)
rel_mul_cancel {x y z} : ¬ rel z 0 → rel (x * z) (y * z) → rel x y
not_rel_one_zero : ¬ rel 1 0
@[inherit_doc] infix:50 " ≤ᵥ " => ValuativeRel.rel
macro_rules | `($a ≤ᵥ $b) => `(binrel% ValuativeRel.rel $a $b) | 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` is equipped with an equivalence class
of valuations. |
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)
rw [mul_right_comm s] at this
have := rel_trans this (rel_mul h3 (rel_refl _))
rw [mul_right_comm r, mul_right_comm t] at this
simpa using this
· have := rel_mul h4 (rel_refl ↑u)
rw [mul_right_comm s] at this
have := rel_trans this (rel_mul h2 (rel_refl _))
rw [mul_right_comm t, mul_right_comm r] at this
simpa using this
}
variable (R) in | 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) : α :=
Quotient.lift₂ (fun (x, t) (y, s) => f x t y s)
(fun (x, t) (z, v) (y, s) (w, u) ⟨h₁, h₂⟩ ⟨h₃, h₄⟩ => hf x y z w s t u v h₁ h₂ h₃ h₄) t₁ 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 → 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 (.mk x z) (.mk y w) = f x z y w := rfl | 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) =
ValueGroupWithZero.lift f hf a * ValueGroupWithZero.lift f hf b := by
induction a using ValueGroupWithZero.ind
induction b using ValueGroupWithZero.ind
simpa using hdist _ _ _ _ | 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_one,
ValueGroupWithZero.mk_le_mk] at h
simp [not_rel_one_zero] at h
inv_zero := dif_pos .rfl
mul_inv_cancel := ValueGroupWithZero.ind fun x y h => by
rw [ne_eq, ← ValueGroupWithZero.mk_zero 1, ValueGroupWithZero.mk_eq_mk] at h
simp only [Submonoid.coe_one, mul_one, zero_mul, zero_rel, and_true] at h
rw [ValueGroupWithZero.inv_mk x y h, ← ValueGroupWithZero.mk_one_one,
ValueGroupWithZero.mk_mul_mk, ValueGroupWithZero.mk_eq_mk]
simp [mul_comm]
variable (R) in
/-- The "canonical" valuation associated to a valuative relation. |
@[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 [map_mul, mul_le_mul_right' h]
rel_mul_cancel h0 h := by
rw [map_zero, le_zero_iff] at h0
simp only [map_mul] at h
exact le_of_mul_le_mul_right h (lt_of_le_of_ne' zero_le' h0)
not_rel_one_zero := by simp | 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.rfl⟩ | 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_ne_zero_of_compatible := _root_.Valuation.apply_posSubmonoid_ne_zero
@[simp] | 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 _ := rel_refl _
le_trans _ _ _ := rel_trans
/-- The valuative relation on `WithPreorder R` arising from the valuative relation on `R`.
This is defined as the preorder itself. -/
instance : ValuativeRel (WithPreorder R) where
rel := (· ≤ ·)
rel_total := rel_total (R := R)
rel_trans := rel_trans (R := R)
rel_add := rel_add (R := R)
rel_mul_right := rel_mul_right (R := R)
rel_mul_cancel := rel_mul_cancel (R := R)
not_rel_one_zero := not_rel_one_zero (R := R)
instance : ValuativePreorder (WithPreorder R) where
rel_iff_le _ _ := Iff.rfl
variable (R) in
/-- The support of the valuation on `R`. |
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⟩
· exact ⟨r.val, by simp, by simpa using hr⟩ | 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, ValueGroupWithZero.mk_eq_one, not_and, valuation, Valuation.coe_mk,
MonoidWithZeroHom.coe_mk, ZeroHom.coe_mk, OneMemClass.coe_one] at hr' hs ⊢
contrapose! hr'
exact hr'.imp hs.right.trans' hs.left.trans
· refine ⟨s, ?_, hs⟩
simp [valuation, ← posSubmonoid_def]
· rintro ⟨r, hr, hr'⟩
exact ⟨valuation R r, hr, hr'⟩
variable (R) in | 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
simp [H, eq_comm] at hab
use a, b | 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 [ValueGroupWithZero.lift_zero]
map_one' := by simp
map_mul' _ _ := by
apply ValuativeRel.ValueGroupWithZero.lift_mul
simp [field]
@[simp] | 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 R) v).lt_iff_lt] at h
simpa [embed] using h | 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 := by split_ifs <;> simp_all | 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_valuation_posSubmonoid_eq a
obtain ⟨t, u, ht⟩ := exists_valuation_posSubmonoid_div_valuation_posSubmonoid_eq b
rw [Units.ext_iff, ← hr, ← ht, div_eq_div_iff, ← map_mul, ← map_mul, this.val_eq] <;>
simp [one_apply_posSubmonoid] | 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.