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 ⌀ |
|---|---|---|---|---|---|---|
map_mul : ∀ (x y : R), v (x * y) = v x + v y :=
Valuation.map_mul v | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_mul | null |
map_add : ∀ (x y : R), min (v x) (v y) ≤ v (x + y) :=
Valuation.map_add v
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_add | null |
map_add' : ∀ (x y : R), v x ≤ v (x + y) ∨ v y ≤ v (x + y) := by
intro x y
rw [← @min_le_iff _ _ (v x) (v y) (v (x+y)), ← ge_iff_le]
apply map_add | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_add' | null |
map_le_add {x y : R} {g : Γ₀} (hx : g ≤ v x) (hy : g ≤ v y) : g ≤ v (x + y) :=
Valuation.map_add_le v hx hy | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_le_add | null |
map_lt_add {x y : R} {g : Γ₀} (hx : g < v x) (hy : g < v y) : g < v (x + y) :=
Valuation.map_add_lt v hx hy | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_lt_add | null |
map_le_sum {ι : Type*} {s : Finset ι} {f : ι → R} {g : Γ₀} (hf : ∀ i ∈ s, g ≤ v (f i)) :
g ≤ v (∑ i ∈ s, f i) :=
v.map_sum_le hf | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_le_sum | null |
map_lt_sum {ι : Type*} {s : Finset ι} {f : ι → R} {g : Γ₀} (hg : g ≠ ⊤)
(hf : ∀ i ∈ s, g < v (f i)) : g < v (∑ i ∈ s, f i) :=
v.map_sum_lt hg hf | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_lt_sum | null |
map_lt_sum' {ι : Type*} {s : Finset ι} {f : ι → R} {g : Γ₀} (hg : g < ⊤)
(hf : ∀ i ∈ s, g < v (f i)) : g < v (∑ i ∈ s, f i) :=
v.map_sum_lt' hg hf
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_lt_sum' | null |
map_pow : ∀ (x : R) (n : ℕ), v (x ^ n) = n • (v x) :=
Valuation.map_pow v
@[ext] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_pow | null |
ext {v₁ v₂ : AddValuation R Γ₀} (h : ∀ r, v₁ r = v₂ r) : v₁ = v₂ :=
Valuation.ext h | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | ext | null |
toPreorder : Preorder R :=
Preorder.lift v | def | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | toPreorder | A valuation gives a preorder on the underlying ring. |
@[simp]
top_iff [Nontrivial Γ₀] (v : AddValuation K Γ₀) {x : K} : v x = (⊤ : Γ₀) ↔ x = 0 :=
v.zero_iff | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | top_iff | If `v` is an additive valuation on a division ring then `v(x) = ⊤` iff `x = 0`. |
ne_top_iff [Nontrivial Γ₀] (v : AddValuation K Γ₀) {x : K} : v x ≠ (⊤ : Γ₀) ↔ x ≠ 0 :=
v.ne_zero_iff | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | ne_top_iff | null |
comap {S : Type*} [Ring S] (f : S →+* R) (v : AddValuation R Γ₀) : AddValuation S Γ₀ :=
Valuation.comap f v
@[simp] | def | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | comap | A ring homomorphism `S → R` induces a map `AddValuation R Γ₀ → AddValuation S Γ₀`. |
comap_id : v.comap (RingHom.id R) = v :=
Valuation.comap_id v | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | comap_id | null |
comap_comp {S₁ : Type*} {S₂ : Type*} [Ring S₁] [Ring S₂] (f : S₁ →+* S₂) (g : S₂ →+* R) :
v.comap (g.comp f) = (v.comap g).comap f :=
Valuation.comap_comp v f g | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | comap_comp | null |
map (f : Γ₀ →+ Γ'₀) (ht : f ⊤ = ⊤) (hf : Monotone f) (v : AddValuation R Γ₀) :
AddValuation R Γ'₀ :=
@Valuation.map R (Multiplicative Γ₀ᵒᵈ) (Multiplicative Γ'₀ᵒᵈ) _ _ _
{ toFun := f
map_mul' := f.map_add
map_one' := f.map_zero
map_zero' := ht } (fun _ _ h => hf h) v
@[simp] | def | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map | A `≤`-preserving, `⊤`-preserving group homomorphism `Γ₀ → Γ'₀` induces a map
`AddValuation R Γ₀ → AddValuation R Γ'₀`. |
map_apply (f : Γ₀ →+ Γ'₀) (ht : f ⊤ = ⊤) (hf : Monotone f) (v : AddValuation R Γ₀) (r : R) :
v.map f ht hf r = f (v r) := rfl | lemma | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_apply | null |
IsEquiv (v₁ : AddValuation R Γ₀) (v₂ : AddValuation R Γ'₀) : Prop :=
Valuation.IsEquiv v₁ v₂
@[simp] | def | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | IsEquiv | Two additive valuations on `R` are defined to be equivalent if they induce the same
preorder on `R`. |
map_neg (x : R) : v (-x) = v x :=
Valuation.map_neg v x | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_neg | null |
map_sub_swap (x y : R) : v (x - y) = v (y - x) :=
Valuation.map_sub_swap v x y | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_sub_swap | null |
map_sub (x y : R) : min (v x) (v y) ≤ v (x - y) :=
Valuation.map_sub v x y | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_sub | null |
map_le_sub {x y : R} {g : Γ₀} (hx : g ≤ v x) (hy : g ≤ v y) : g ≤ v (x - y) :=
Valuation.map_sub_le v hx hy
variable {x y : R} | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_le_sub | null |
map_add_of_distinct_val (h : v x ≠ v y) : v (x + y) = @Min.min Γ₀ _ (v x) (v y) :=
Valuation.map_add_of_distinct_val v h | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_add_of_distinct_val | null |
map_add_eq_of_lt_left {x y : R} (h : v x < v y) :
v (x + y) = v x := by
rw [map_add_of_distinct_val _ h.ne, min_eq_left h.le] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_add_eq_of_lt_left | null |
map_add_eq_of_lt_right {x y : R} (hx : v y < v x) :
v (x + y) = v y := add_comm y x ▸ map_add_eq_of_lt_left v hx | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_add_eq_of_lt_right | null |
map_sub_eq_of_lt_left {x y : R} (hx : v x < v y) :
v (x - y) = v x := by
rw [sub_eq_add_neg]
apply map_add_eq_of_lt_left
rwa [map_neg] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_sub_eq_of_lt_left | null |
map_sub_eq_of_lt_right {x y : R} (hx : v y < v x) :
v (x - y) = v y := map_sub_swap v x y ▸ map_sub_eq_of_lt_left v hx | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_sub_eq_of_lt_right | null |
map_eq_of_lt_sub (h : v x < v (y - x)) : v y = v x :=
Valuation.map_eq_of_sub_lt v h | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_eq_of_lt_sub | null |
@[simp]
map_inv (v : AddValuation K Γ₀) {x : K} : v x⁻¹ = - (v x) :=
map_inv₀ (toValuation v) x
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_inv | null |
map_div (v : AddValuation K Γ₀) {x y : K} : v (x / y) = v x - v y :=
map_div₀ (toValuation v) x y | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_div | null |
@[refl]
refl : v.IsEquiv v :=
Valuation.IsEquiv.refl
@[symm] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | refl | null |
symm (h : v₁.IsEquiv v₂) : v₂.IsEquiv v₁ :=
Valuation.IsEquiv.symm h
@[trans] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | symm | null |
trans (h₁₂ : v₁.IsEquiv v₂) (h₂₃ : v₂.IsEquiv v₃) : v₁.IsEquiv v₃ :=
Valuation.IsEquiv.trans h₁₂ h₂₃ | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | trans | null |
of_eq {v' : AddValuation R Γ₀} (h : v = v') : v.IsEquiv v' :=
Valuation.IsEquiv.of_eq h | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | of_eq | null |
map {v' : AddValuation R Γ₀} (f : Γ₀ →+ Γ'₀) (ht : f ⊤ = ⊤) (hf : Monotone f)
(inf : Injective f) (h : v.IsEquiv v') : (v.map f ht hf).IsEquiv (v'.map f ht hf) :=
@Valuation.IsEquiv.map R (Multiplicative Γ₀ᵒᵈ) (Multiplicative Γ'₀ᵒᵈ) _ _ _ _ _
{ toFun := f
map_mul' := f.map_add
map_one' := f.map_zero
map_zero' := ht } (fun _x _y h => hf h) inf h | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map | null |
comap {S : Type*} [Ring S] (f : S →+* R) (h : v₁.IsEquiv v₂) :
(v₁.comap f).IsEquiv (v₂.comap f) :=
Valuation.IsEquiv.comap f h | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | comap | `comap` preserves equivalence. |
val_eq (h : v₁.IsEquiv v₂) {r s : R} : v₁ r = v₁ s ↔ v₂ r = v₂ s :=
Valuation.IsEquiv.val_eq h | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | val_eq | null |
ne_top (h : v₁.IsEquiv v₂) {r : R} : v₁ r ≠ (⊤ : Γ₀) ↔ v₂ r ≠ (⊤ : Γ'₀) :=
Valuation.IsEquiv.ne_zero h | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | ne_top | null |
supp : Ideal R :=
Valuation.supp v
@[simp] | def | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | supp | The support of an additive valuation `v : R → Γ₀` is the ideal of `R` where `v x = ⊤` |
mem_supp_iff (x : R) : x ∈ supp v ↔ v x = (⊤ : Γ₀) :=
Valuation.mem_supp_iff v x | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | mem_supp_iff | null |
map_add_supp (a : R) {s : R} (h : s ∈ supp v) : v (a + s) = v a :=
Valuation.map_add_supp v a h | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | map_add_supp | null |
toAddValuation : Valuation R Γ₀ ≃ AddValuation R (Additive Γ₀)ᵒᵈ :=
.trans (congr
{ toFun := fun x ↦ .ofAdd <| .toDual <| .toDual <| .ofMul x
invFun := fun x ↦ x.toAdd.ofDual.ofDual.toMul
map_mul' := fun _x _y ↦ rfl
map_le_map_iff' := .rfl }) (AddValuation.ofValuation (R := R) (Γ₀ := (Additive Γ₀)ᵒᵈ)) | def | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | toAddValuation | The `AddValuation` associated to a `Valuation`. |
ofAddValuation : AddValuation R (Additive Γ₀)ᵒᵈ ≃ Valuation R Γ₀ :=
AddValuation.toValuation.trans <| congr <|
{ toFun := fun x ↦ x.toAdd.ofDual.ofDual.toMul
invFun := fun x ↦ .ofAdd <| .toDual <| .toDual <| .ofMul x
map_mul' := fun _x _y ↦ rfl
map_le_map_iff' := .rfl }
@[simp] | def | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | ofAddValuation | The `Valuation` associated to a `AddValuation`. |
ofAddValuation_symm_eq : ofAddValuation.symm = toAddValuation (R := R) (Γ₀ := Γ₀) := rfl
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | ofAddValuation_symm_eq | null |
toAddValuation_symm_eq : toAddValuation.symm = ofAddValuation (R := R) (Γ₀ := Γ₀) := rfl
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | toAddValuation_symm_eq | null |
ofAddValuation_toAddValuation (v : Valuation R Γ₀) : ofAddValuation (toAddValuation v) = v :=
rfl
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | ofAddValuation_toAddValuation | null |
toValuation_ofValuation (v : AddValuation R (Additive Γ₀)ᵒᵈ) :
toAddValuation (ofAddValuation v) = v := rfl
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | toValuation_ofValuation | null |
toAddValuation_apply (v : Valuation R Γ₀) (r : R) :
toAddValuation v r = OrderDual.toDual (Additive.ofMul (v r)) :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | toAddValuation_apply | null |
ofAddValuation_apply (v : AddValuation R (Additive Γ₀)ᵒᵈ) (r : R) :
ofAddValuation v r = Additive.toMul (OrderDual.ofDual (v r)) :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | ofAddValuation_apply | null |
@[simp]
val_mrange_zero (v : Valuation R Γ₀) : ((0 : MonoidHom.mrange v) : Γ₀) = 0 := by
rfl | lemma | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | val_mrange_zero | null |
nonempty_orderIso_withZeroMul_int_iff :
Nonempty (ValueGroupWithZero R ≃*o ℤᵐ⁰) ↔
IsDiscrete R ∧ IsNontrivial R ∧ MulArchimedean (ValueGroupWithZero R) := by
constructor
· rintro ⟨e⟩
let x := e.symm (exp (-1))
have hx0 : x ≠ 0 := by simp [x]
have hx1 : x < 1 := by simp [- exp_neg, x, ← lt_map_inv_iff, ← exp_zero]
refine ⟨⟨x, hx1, fun y hy ↦ ?_⟩, ⟨x, hx0, hx1.ne⟩, .comap e.toMonoidHom e.strictMono⟩
rcases eq_or_ne y 0 with rfl | hy0
· simp
· rw [← map_one e.symm, ← map_inv_lt_iff, ← log_lt_log (by simp [hy0]) (by simp)] at hy
rw [← map_inv_le_iff, ← log_le_log (by simp [hy0]) (by simp)]
simp only [OrderMonoidIso.equivLike_inv_eq_symm, OrderMonoidIso.symm_symm, log_one,
log_exp] at hy ⊢
linarith
· rintro ⟨hD, hN, hM⟩
rw [isNontrivial_iff_nontrivial_units] at hN
rw [LinearOrderedCommGroupWithZero.discrete_iff_not_denselyOrdered]
intro H
obtain ⟨x, hx, hx'⟩ := hD.has_maximal_element
obtain ⟨y, hy, hy'⟩ := exists_between hx
exact hy.not_ge (hx' y hy') | lemma | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Range",
"Mathlib.GroupTheory.ArchimedeanDensely",
"Mathlib.RingTheory.Valuation.RankOne"
] | Mathlib/RingTheory/Valuation/DiscreteValuativeRel.lean | nonempty_orderIso_withZeroMul_int_iff | null |
IsDiscrete.of_compatible_withZeroMulInt (v : Valuation R ℤᵐ⁰) [v.Compatible] :
IsDiscrete R := by
have : IsRankLeOne R := .of_compatible_mulArchimedean v
by_cases h : IsNontrivial R
· by_cases H : DenselyOrdered (ValueGroupWithZero R)
· exfalso
refine (MonoidWithZeroHom.range_nontrivial (ValueGroupWithZero.embed v)).not_subsingleton ?_
rw [← WithZero.denselyOrdered_set_iff_subsingleton]
exact (ValueGroupWithZero.embed_strictMono v).denselyOrdered_range
· rw [isNontrivial_iff_nontrivial_units] at h
rw [← LinearOrderedCommGroupWithZero.discrete_iff_not_denselyOrdered] at H
rw [nonempty_orderIso_withZeroMul_int_iff] at H
exact H.left
· rw [isNontrivial_iff_nontrivial_units] at h; push_neg at h
refine ⟨⟨0, zero_lt_one, fun y hy ↦ ?_⟩⟩
contrapose! hy
have : 1 = Units.mk0 y hy.ne' := Subsingleton.elim _ _
exact Units.val_le_val.mpr this.le | lemma | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Range",
"Mathlib.GroupTheory.ArchimedeanDensely",
"Mathlib.RingTheory.Valuation.RankOne"
] | Mathlib/RingTheory/Valuation/DiscreteValuativeRel.lean | IsDiscrete.of_compatible_withZeroMulInt | null |
noncomputable Valuation.extendToLocalization : Valuation B Γ :=
let f := IsLocalization.toLocalizationMap S B
let h : ∀ s : S, IsUnit (v.1.toMonoidHom s) := fun s => isUnit_iff_ne_zero.2 (hS s.2)
{ f.lift h with
map_zero' := by convert f.lift_eq (P := Γ) _ 0 <;> simp [f]
map_add_le_max' := fun x y => by
obtain ⟨a, b, s, rfl, rfl⟩ : ∃ (a b : A) (s : S), f.mk' a s = x ∧ f.mk' b s = y := by
obtain ⟨a, s, rfl⟩ := f.mk'_surjective x
obtain ⟨b, t, rfl⟩ := f.mk'_surjective y
use a * t, b * s, s * t
constructor <;>
· rw [f.mk'_eq_iff_eq, Submonoid.coe_mul]
ring_nf
convert_to f.lift h (f.mk' (a + b) s) ≤ max (f.lift h _) (f.lift h _)
· refine congr_arg (f.lift h) (IsLocalization.eq_mk'_iff_mul_eq.2 ?_)
rw [add_mul, map_add]
rw [← IsLocalization.toLocalizationMap_apply S B, f.mk'_spec, f.mk'_spec,
IsLocalization.toLocalizationMap_apply,
IsLocalization.toLocalizationMap_apply]
iterate 3 rw [f.lift_mk']
rw [max_mul_mul_right]
apply mul_le_mul_right' (v.map_add a b) }
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/ExtendToLocalization.lean | Valuation.extendToLocalization | We can extend a valuation `v` on a ring to a localization at a submonoid of
the complement of `v.supp`. |
Valuation.extendToLocalization_mk' (x : A) (y : S) :
(v.extendToLocalization hS B) (IsLocalization.mk' _ x y) =
v x * (v y)⁻¹ :=
(Submonoid.LocalizationMap.lift_mk' _ _ _ _).trans (by simp [IsUnit.coe_liftRight])
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/ExtendToLocalization.lean | Valuation.extendToLocalization_mk' | null |
Valuation.extendToLocalization_apply_map_apply (a : A) :
v.extendToLocalization hS B (algebraMap A B a) = v a :=
Submonoid.LocalizationMap.lift_eq _ _ a | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/ExtendToLocalization.lean | Valuation.extendToLocalization_apply_map_apply | null |
HasExtension : Prop where
/-- The valuation `vR` on `R` is equivalent to the comap of the valuation `vA` on `A` -/
val_isEquiv_comap : vR.IsEquiv <| vA.comap (algebraMap R A)
@[deprecated (since := "2025-04-02")] alias _root_.IsValExtension := HasExtension | class | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/Extension.lean | HasExtension | The class `Valuation.HasExtension vR vA` states that the valuation `vA` on `A` is an extension of
the valuation `vR` on `R`. More precisely, `vR` is equivalent to the comap of the valuation `vA`. |
val_map_le_iff (x y : R) : vA (algebraMap R A x) ≤ vA (algebraMap R A y) ↔ vR x ≤ vR y :=
val_isEquiv_comap.symm x y | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/Extension.lean | val_map_le_iff | null |
val_map_lt_iff (x y : R) : vA (algebraMap R A x) < vA (algebraMap R A y) ↔ vR x < vR y := by
simpa only [not_le] using ((val_map_le_iff vR vA _ _).not) | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/Extension.lean | val_map_lt_iff | null |
val_map_eq_iff (x y : R) : vA (algebraMap R A x) = vA (algebraMap R A y) ↔ vR x = vR y :=
(IsEquiv.val_eq val_isEquiv_comap).symm | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/Extension.lean | val_map_eq_iff | null |
val_map_le_one_iff (x : R) : vA (algebraMap R A x) ≤ 1 ↔ vR x ≤ 1 := by
simpa only [map_one] using val_map_le_iff vR vA x 1 | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/Extension.lean | val_map_le_one_iff | null |
val_map_lt_one_iff (x : R) : vA (algebraMap R A x) < 1 ↔ vR x < 1 := by
simpa only [map_one, not_le] using (val_map_le_iff vR vA 1 x).not | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/Extension.lean | val_map_lt_one_iff | null |
val_map_eq_one_iff (x : R) : vA (algebraMap R A x) = 1 ↔ vR x = 1 := by
simpa only [le_antisymm_iff, map_one] using
and_congr (val_map_le_iff vR vA x 1) (val_map_le_iff vR vA 1 x) | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/Extension.lean | val_map_eq_one_iff | null |
id : vR.HasExtension vR where
val_isEquiv_comap := by
simp only [Algebra.algebraMap_self, comap_id, IsEquiv.refl] | instance | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/Extension.lean | id | null |
ofComapInteger (h : vA.integer.comap (algebraMap K A) = vK.integer) :
vK.HasExtension vA where
val_isEquiv_comap := by
rw [isEquiv_iff_val_le_one]
intro x
simp_rw [← Valuation.mem_integer_iff, ← h, Subring.mem_comap, mem_integer_iff, comap_apply] | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/Extension.lean | ofComapInteger | When `K` is a field, if the preimage of the valuation integers of `A` equals to the valuation
integers of `K`, then the valuation on `A` is an extension of the valuation on `K`. |
instAlgebraInteger : Algebra vR.integer vA.integer where
smul r a := ⟨r • a,
Algebra.smul_def r (a : A) ▸ mul_mem ((val_map_le_one_iff vR vA _).mpr r.2) a.2⟩
algebraMap := (algebraMap R A).restrict vR.integer vA.integer
(by simp [Valuation.mem_integer_iff, val_map_le_one_iff vR vA])
commutes' _ _ := Subtype.ext (Algebra.commutes _ _)
smul_def' _ _ := Subtype.ext (Algebra.smul_def _ _)
@[simp, norm_cast] | instance | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/Extension.lean | instAlgebraInteger | null |
val_smul (r : vR.integer) (a : vA.integer) : ↑(r • a : vA.integer) = (r : R) • (a : A) := by
rfl
@[simp, norm_cast] | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/Extension.lean | val_smul | null |
val_algebraMap (r : vR.integer) :
((algebraMap vR.integer vA.integer) r : A) = (algebraMap R A) (r : R) := by
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/Extension.lean | val_algebraMap | null |
instIsScalarTowerInteger : IsScalarTower vR.integer vA.integer A where
smul_assoc x y z := by
simp only [Algebra.smul_def]
exact mul_assoc _ _ _ | instance | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/Extension.lean | instIsScalarTowerInteger | null |
instNoZeroSMulDivisorsInteger [NoZeroSMulDivisors R A] :
NoZeroSMulDivisors vR.integer vA.integer := by
refine ⟨fun {x y} e ↦ ?_⟩
have : (x : R) • (y : A) = 0 := by simpa [Subtype.ext_iff, Algebra.smul_def] using e
simpa only [Subtype.ext_iff, smul_eq_zero] using this | instance | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/Extension.lean | instNoZeroSMulDivisorsInteger | null |
algebraMap_injective [vK.HasExtension vA] [Nontrivial A] :
Function.Injective (algebraMap vK.integer vA.integer) :=
FaithfulSMul.algebraMap_injective _ _
@[instance] | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/Extension.lean | algebraMap_injective | null |
instIsLocalHomValuationInteger {S ΓS : Type*} [CommRing S]
[LinearOrderedCommGroupWithZero ΓS]
[Algebra R S] [IsLocalHom (algebraMap R S)] {vS : Valuation S ΓS}
[vR.HasExtension vS] : IsLocalHom (algebraMap vR.integer vS.integer) where
map_nonunit r hr := by
apply (Valuation.integer.integers (v := vR)).isUnit_of_one
· exact (isUnit_map_iff (algebraMap R S) _).mp (hr.map (algebraMap _ S))
· apply (Valuation.integer.integers (v := vS)).one_of_isUnit at hr
exact (val_map_eq_one_iff vR vS _).mp hr | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/Extension.lean | instIsLocalHomValuationInteger | null |
algebraMap_mem_valuationSubring (x : K₀) : algebraMap K L x ∈ L₀ := by
rw [mem_valuationSubring_iff, ← _root_.map_one vL, ← _root_.map_one (algebraMap K L),
val_map_le_iff (vR := vK), _root_.map_one]
exact x.2 | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/Extension.lean | algebraMap_mem_valuationSubring | null |
instAlgebra_valuationSubring : Algebra K₀ L₀ :=
inferInstanceAs (Algebra vK.integer vL.integer)
@[simp] | instance | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/Extension.lean | instAlgebra_valuationSubring | null |
coe_algebraMap_valuationSubring_eq (x : K₀) :
(algebraMap K₀ L₀ x : L) = algebraMap K L (x : K) := rfl | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/Extension.lean | coe_algebraMap_valuationSubring_eq | null |
instIsScalarTower_valuationSubring : IsScalarTower K₀ K L :=
inferInstanceAs (IsScalarTower vK.integer K L) | instance | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/Extension.lean | instIsScalarTower_valuationSubring | null |
instIsScalarTower_valuationSubring' : IsScalarTower K₀ L₀ L :=
instIsScalarTowerInteger | instance | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/Extension.lean | instIsScalarTower_valuationSubring' | null |
algebraMap_mem_maximalIdeal_iff {x : K₀} :
algebraMap K₀ L₀ x ∈ (maximalIdeal L₀) ↔ x ∈ maximalIdeal K₀ := by
simp [mem_maximalIdeal, map_mem_nonunits_iff, _root_.mem_nonunits_iff] | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/Extension.lean | algebraMap_mem_maximalIdeal_iff | null |
maximalIdeal_comap_algebraMap_eq_maximalIdeal :
(maximalIdeal L₀).comap (algebraMap K₀ L₀) = maximalIdeal K₀ :=
Ideal.ext fun _ ↦ by rw [Ideal.mem_comap, algebraMap_mem_maximalIdeal_iff] | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/Extension.lean | maximalIdeal_comap_algebraMap_eq_maximalIdeal | null |
algebraMap_residue_eq_residue_algebraMap (x : K₀) :
(algebraMap (ResidueField K₀) (ResidueField L₀)) (IsLocalRing.residue K₀ x) =
IsLocalRing.residue L₀ (algebraMap K₀ L₀ x) :=
rfl | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.ValuationSubring"
] | Mathlib/RingTheory/Valuation/Extension.lean | algebraMap_residue_eq_residue_algebraMap | null |
integer : Subring R where
carrier := { x | v x ≤ 1 }
one_mem' := le_of_eq v.map_one
mul_mem' {x y} hx hy := by simp only [Set.mem_setOf_eq, map_mul, mul_le_one' hx hy]
zero_mem' := by simp only [Set.mem_setOf_eq, map_zero, zero_le']
add_mem' {x y} hx hy := le_trans (v.map_add x y) (max_le hx hy)
neg_mem' {x} hx := by simp only [Set.mem_setOf_eq] at hx; simpa only [Set.mem_setOf_eq, map_neg] | def | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | integer | The ring of integers under a given valuation is the subring of elements with valuation ≤ 1. |
mem_integer_iff (r : R) : r ∈ v.integer ↔ v r ≤ 1 := by rfl | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | mem_integer_iff | null |
Integers : Prop where
hom_inj : Function.Injective (algebraMap O R)
map_le_one : ∀ x, v (algebraMap O R x) ≤ 1
exists_of_le_one : ∀ ⦃r⦄, v r ≤ 1 → ∃ x, algebraMap O R x = r | structure | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | Integers | Given a valuation v : R → Γ₀ and a ring homomorphism O →+* R, we say that O is the integers of v
if f is injective, and its range is exactly `v.integer`. |
integer.integers : v.Integers v.integer :=
{ hom_inj := Subtype.coe_injective
map_le_one := fun r => r.2
exists_of_le_one := fun r hr => ⟨⟨r, hr⟩, rfl⟩ } | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | integer.integers | null |
one_of_isUnit' {x : O} (hx : IsUnit x) (H : ∀ x, v (algebraMap O R x) ≤ 1) :
v (algebraMap O R x) = 1 :=
let ⟨u, hu⟩ := hx
le_antisymm (H _) <| by
rw [← v.map_one, ← (algebraMap O R).map_one, ← u.mul_inv, ← mul_one (v (algebraMap O R x)), hu,
(algebraMap O R).map_mul, v.map_mul]
exact mul_le_mul_left' (H (u⁻¹ : Units O)) _ | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | one_of_isUnit' | null |
one_of_isUnit (hv : Integers v O) {x : O} (hx : IsUnit x) : v (algebraMap O R x) = 1 :=
one_of_isUnit' hx hv.map_le_one | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | one_of_isUnit | null |
isUnit_of_one (hv : Integers v O) {x : O} (hx : IsUnit (algebraMap O R x))
(hvx : v (algebraMap O R x) = 1) : IsUnit x :=
let ⟨u, hu⟩ := hx
have h1 : v u ≤ 1 := hu.symm ▸ hv.2 x
have h2 : v (u⁻¹ : Rˣ) ≤ 1 := by
rw [← one_mul (v _), ← hvx, ← v.map_mul, ← hu, u.mul_inv, hu, hvx, v.map_one]
let ⟨r1, hr1⟩ := hv.3 h1
let ⟨r2, hr2⟩ := hv.3 h2
⟨⟨r1, r2, hv.1 <| by rw [RingHom.map_mul, RingHom.map_one, hr1, hr2, Units.mul_inv],
hv.1 <| by rw [RingHom.map_mul, RingHom.map_one, hr1, hr2, Units.inv_mul]⟩,
hv.1 <| hr1.trans hu⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | isUnit_of_one | Let `O` be the integers of the valuation `v` on some commutative ring `R`. For every element `x` in
`O`, `x` is a unit in `O` if and only if the image of `x` in `R` is a unit and has valuation 1. |
le_of_dvd (hv : Integers v O) {x y : O} (h : x ∣ y) :
v (algebraMap O R y) ≤ v (algebraMap O R x) := by
let ⟨z, hz⟩ := h
rw [← mul_one (v (algebraMap O R x)), hz, RingHom.map_mul, v.map_mul]
exact mul_le_mul_left' (hv.2 z) _ | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | le_of_dvd | null |
nontrivial_iff (hv : v.Integers O) : Nontrivial O ↔ Nontrivial R := by
constructor <;> intro h
· exact hv.hom_inj.nontrivial
· obtain ⟨o0, ho0⟩ := hv.exists_of_le_one (r := 0) (by simp)
obtain ⟨o1, ho1⟩ := hv.exists_of_le_one (r := 1) (by simp)
refine ⟨o0, o1, ?_⟩
rintro rfl
simp [ho1] at ho0 | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | nontrivial_iff | null |
integers_nontrivial (v : Valuation R Γ₀) :
Nontrivial v.integer ↔ Nontrivial R :=
(Valuation.integer.integers v).nontrivial_iff | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | integers_nontrivial | null |
dvd_of_le (hv : Integers v O) {x y : O}
(h : v (algebraMap O F x) ≤ v (algebraMap O F y)) : y ∣ x :=
by_cases
(fun hy : algebraMap O F y = 0 =>
have hx : x = 0 :=
hv.1 <|
(algebraMap O F).map_zero.symm ▸ (v.zero_iff.1 <| le_zero_iff.1 (v.map_zero ▸ hy ▸ h))
hx.symm ▸ dvd_zero y)
fun hy : algebraMap O F y ≠ 0 =>
have : v ((algebraMap O F y)⁻¹ * algebraMap O F x) ≤ 1 := by
rw [← v.map_one, ← inv_mul_cancel₀ hy, v.map_mul, v.map_mul]
exact mul_le_mul_left' h _
let ⟨z, hz⟩ := hv.3 this
⟨z, hv.1 <| ((algebraMap O F).map_mul y z).symm ▸ hz.symm ▸ (mul_inv_cancel_left₀ hy _).symm⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | dvd_of_le | null |
dvd_iff_le (hv : Integers v O) {x y : O} :
x ∣ y ↔ v (algebraMap O F y) ≤ v (algebraMap O F x) :=
⟨hv.le_of_dvd, hv.dvd_of_le⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | dvd_iff_le | null |
le_iff_dvd (hv : Integers v O) {x y : O} :
v (algebraMap O F x) ≤ v (algebraMap O F y) ↔ y ∣ x :=
⟨hv.dvd_of_le, hv.le_of_dvd⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | le_iff_dvd | null |
isUnit_of_one' (hv : Integers v O) {x : O} (hvx : v (algebraMap O F x) = 1) : IsUnit x := by
refine isUnit_of_one hv (IsUnit.mk0 _ ?_) hvx
simp only [← v.ne_zero_iff, hvx, ne_eq, one_ne_zero, not_false_eq_true] | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | isUnit_of_one' | This is the special case of `Valuation.Integers.isUnit_of_one` when the valuation is defined
over a field. Let `v` be a valuation on some field `F` and `O` be its integers. For every element
`x` in `O`, `x` is a unit in `O` if and only if the image of `x` in `F` has valuation 1. |
isUnit_iff_valuation_eq_one (hv : Integers v O) {x : O} :
IsUnit x ↔ v (algebraMap O F x) = 1 :=
⟨hv.one_of_isUnit, hv.isUnit_of_one'⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | isUnit_iff_valuation_eq_one | null |
valuation_irreducible_lt_one (hv : Integers v O) {ϖ : O} (h : Irreducible ϖ) :
v (algebraMap O F ϖ) < 1 :=
lt_of_le_of_ne (hv.map_le_one ϖ) (mt hv.isUnit_iff_valuation_eq_one.mpr h.not_isUnit) | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | valuation_irreducible_lt_one | null |
valuation_unit (hv : Integers v O) (x : Oˣ) :
v (algebraMap O F x) = 1 := by
simp [← hv.isUnit_iff_valuation_eq_one] | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | valuation_unit | null |
valuation_pos_iff_ne_zero (hv : Integers v O) {x : O} :
0 < v (algebraMap O F x) ↔ x ≠ 0 := by
rw [← not_le]
refine not_congr ?_
simp [map_eq_zero_iff _ hv.hom_inj] | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | valuation_pos_iff_ne_zero | null |
valuation_irreducible_pos (hv : Integers v O) {ϖ : O} (h : Irreducible ϖ) :
0 < v (algebraMap O F ϖ) :=
hv.valuation_pos_iff_ne_zero.mpr h.ne_zero | lemma | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | valuation_irreducible_pos | null |
dvdNotUnit_iff_lt (hv : Integers v O) {x y : O} :
DvdNotUnit x y ↔ v (algebraMap O F y) < v (algebraMap O F x) := by
rw [lt_iff_le_not_ge, hv.le_iff_dvd, hv.le_iff_dvd]
refine ⟨?_, And.elim dvdNotUnit_of_dvd_of_not_dvd⟩
rintro ⟨hx0, d, hdu, rfl⟩
refine ⟨⟨d, rfl⟩, ?_⟩
rw [hv.isUnit_iff_valuation_eq_one, ← ne_eq, ne_iff_lt_iff_le.mpr (hv.map_le_one d)] at hdu
rw [dvd_iff_le hv]
simp only [map_mul, not_le]
contrapose! hdu
refine one_le_of_le_mul_left₀ ?_ hdu
simp [hv.valuation_pos_iff_ne_zero, hx0] | theorem | RingTheory | [
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/Valuation/Integers.lean | dvdNotUnit_iff_lt | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.