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_add_le {x y g} (hx : v x ≤ g) (hy : v y ≤ g) : v (x + y) ≤ g :=
le_trans (v.map_add x y) <| max_le 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_add_le | null |
map_add_lt {x y g} (hx : v x < g) (hy : v y < g) : v (x + y) < g :=
lt_of_le_of_lt (v.map_add x y) <| max_lt 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_add_lt | null |
map_sum_le {ι : Type*} {s : Finset ι} {f : ι → R} {g : Γ₀} (hf : ∀ i ∈ s, v (f i) ≤ g) :
v (∑ i ∈ s, f i) ≤ g := by
classical
refine
Finset.induction_on s (fun _ => v.map_zero ▸ zero_le')
(fun a s has ih hf => ?_) hf
rw [Finset.forall_mem_insert] at hf; rw [Finset.sum_insert has]
exact v.map_add_le hf.1 (ih hf.2) | 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_sum_le | null |
map_sum_lt {ι : Type*} {s : Finset ι} {f : ι → R} {g : Γ₀} (hg : g ≠ 0)
(hf : ∀ i ∈ s, v (f i) < g) : v (∑ i ∈ s, f i) < g := by
classical
refine
Finset.induction_on s (fun _ => v.map_zero ▸ (zero_lt_iff.2 hg))
(fun a s has ih hf => ?_) hf
rw [Finset.forall_mem_insert] at hf; rw [Finset.sum_insert has]
exact v.map_add_lt hf.1 (ih hf.2) | 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_sum_lt | null |
map_sum_lt' {ι : Type*} {s : Finset ι} {f : ι → R} {g : Γ₀} (hg : 0 < g)
(hf : ∀ i ∈ s, v (f i) < g) : v (∑ i ∈ s, f i) < g :=
v.map_sum_lt (ne_of_gt 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_sum_lt' | null |
protected map_pow : ∀ (x) (n : ℕ), v (x ^ n) = v x ^ n :=
v.toMonoidWithZeroHom.toMonoidHom.map_pow | 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 |
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. |
zero_iff [Nontrivial Γ₀] (v : Valuation K Γ₀) {x : K} : v x = 0 ↔ x = 0 :=
map_eq_zero 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 | zero_iff | If `v` is a valuation on a division ring then `v(x) = 0` iff `x = 0`. |
ne_zero_iff [Nontrivial Γ₀] (v : Valuation K Γ₀) {x : K} : v x ≠ 0 ↔ x ≠ 0 :=
map_ne_zero 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 | ne_zero_iff | null |
pos_iff [Nontrivial Γ₀] (v : Valuation K Γ₀) {x : K} : 0 < v x ↔ x ≠ 0 := by
rw [zero_lt_iff, ne_zero_iff] | 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 | pos_iff | null |
unit_map_eq (u : Rˣ) : (Units.map (v : R →* Γ₀) u : Γ₀) = v u :=
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 | unit_map_eq | null |
ne_zero_of_unit [Nontrivial Γ₀] (v : Valuation K Γ₀) (x : Kˣ) : v x ≠ (0 : Γ₀) := by
simp only [ne_eq, Valuation.zero_iff, Units.ne_zero x, not_false_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_zero_of_unit | null |
ne_zero_of_isUnit [Nontrivial Γ₀] (v : Valuation K Γ₀) (x : K) (hx : IsUnit x) :
v x ≠ (0 : Γ₀) := by
simpa [hx.choose_spec] using ne_zero_of_unit v hx.choose | 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_zero_of_isUnit | null |
comap {S : Type*} [Ring S] (f : S →+* R) (v : Valuation R Γ₀) : Valuation S Γ₀ :=
{ v.toMonoidWithZeroHom.comp f.toMonoidWithZeroHom with
toFun := v ∘ f
map_add_le_max' := fun x y => by simp only [comp_apply, v.map_add, map_add] }
@[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 `Valuation R Γ₀ → Valuation S Γ₀`. |
comap_apply {S : Type*} [Ring S] (f : S →+* R) (v : Valuation R Γ₀) (s : S) :
v.comap f s = v (f s) := 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 | comap_apply | null |
comap_id : v.comap (RingHom.id R) = v :=
ext fun _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 | 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 :=
ext fun _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 | comap_comp | null |
map (f : Γ₀ →*₀ Γ'₀) (hf : Monotone f) (v : Valuation R Γ₀) : Valuation R Γ'₀ :=
{ MonoidWithZeroHom.comp f v.toMonoidWithZeroHom with
toFun := f ∘ v
map_add_le_max' := fun r s =>
calc
f (v (r + s)) ≤ f (max (v r) (v s)) := hf (v.map_add r s)
_ = max (f (v r)) (f (v s)) := hf.map_max
}
@[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 group homomorphism `Γ₀ → Γ'₀` induces a map `Valuation R Γ₀ → Valuation R Γ'₀`. |
map_apply (f : Γ₀ →*₀ Γ'₀) (hf : Monotone f) (v : Valuation R Γ₀) (r : R) :
v.map f 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₁ : Valuation R Γ₀) (v₂ : Valuation R Γ'₀) : Prop :=
∀ r s, v₁ r ≤ v₁ s ↔ v₂ r ≤ v₂ s
@[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 valuations on `R` are defined to be equivalent if they induce the same preorder on `R`. |
map_neg (x : R) : v (-x) = v x :=
v.toMonoidWithZeroHom.toMonoidHom.map_neg 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) :=
v.toMonoidWithZeroHom.toMonoidHom.map_sub_swap 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) : v (x - y) ≤ max (v x) (v y) :=
calc
v (x - y) = v (x + -y) := by rw [sub_eq_add_neg]
_ ≤ max (v x) (v <| -y) := v.map_add _ _
_ = max (v x) (v y) := by rw [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 | null |
map_sub_le {x y g} (hx : v x ≤ g) (hy : v y ≤ g) : v (x - y) ≤ g := by
rw [sub_eq_add_neg]
exact v.map_add_le hx <| (v.map_neg y).trans_le 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_sub_le | null |
map_sub_lt {x y : R} {g : Γ₀} (hx : v x < g) (hy : v y < g) : v (x - y) < g := by
rw [sub_eq_add_neg]
exact v.map_add_lt hx <| (v.map_neg y).trans_lt hy
variable {x y : R}
@[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_sub_lt | null |
le_one_of_subsingleton [Subsingleton R] (v : Valuation R Γ₀) {x : R} :
v x ≤ 1 := by
rw [Subsingleton.elim x 1, Valuation.map_one] | 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 | le_one_of_subsingleton | null |
map_add_of_distinct_val (h : v x ≠ v y) : v (x + y) = max (v x) (v y) := by
suffices ¬v (x + y) < max (v x) (v y) from
or_iff_not_imp_right.1 (le_iff_eq_or_lt.1 (v.map_add x y)) this
intro h'
wlog vyx : v y < v x generalizing x y
· refine this h.symm ?_ (h.lt_or_gt.resolve_right vyx)
rwa [add_comm, max_comm]
rw [max_eq_left_of_lt vyx] at h'
apply lt_irrefl (v x)
calc
v x = v (x + y - y) := by simp
_ ≤ max (v <| x + y) (v y) := map_sub _ _ _
_ < v x := max_lt h' vyx | 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_right (h : v x < v y) : v (x + y) = v y :=
(v.map_add_of_distinct_val h.ne).trans (max_eq_right_iff.mpr 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_right | null |
map_add_eq_of_lt_left (h : v y < v x) : v (x + y) = v x := by
rw [add_comm]; exact map_add_eq_of_lt_right _ 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_eq_of_lt_left | null |
map_sub_eq_of_lt_right (h : v x < v y) : v (x - y) = v y := by
rw [sub_eq_add_neg, map_add_eq_of_lt_right, map_neg]
rwa [map_neg]
open scoped Classical in | 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_sum_eq_of_lt {ι : Type*} {s : Finset ι} {f : ι → R} {j : ι}
(hj : j ∈ s) (h0 : v (f j) ≠ 0) (hf : ∀ i ∈ s \ {j}, v (f i) < v (f j)) :
v (∑ i ∈ s, f i) = v (f j) := by
rw [Finset.sum_eq_add_sum_diff_singleton hj]
exact map_add_eq_of_lt_left _ (map_sum_lt _ h0 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_sum_eq_of_lt | null |
map_sub_eq_of_lt_left (h : v y < v x) : v (x - y) = v x := by
rw [sub_eq_add_neg, 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_eq_of_sub_lt (h : v (y - x) < v x) : v y = v x := by
have := Valuation.map_add_of_distinct_val v (ne_of_gt h).symm
rw [max_eq_right (le_of_lt h)] at this
simpa using this | 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_sub_lt | null |
map_sub_of_left_eq_zero (hx : v x = 0) : v (x - y) = v y := by
by_cases hy : v y = 0
· simpa [*] using map_sub v x y
· simp [*, map_sub_eq_of_lt_right, zero_lt_iff] | 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_sub_of_left_eq_zero | null |
map_sub_of_right_eq_zero (hy : v y = 0) : v (x - y) = v x := by
rw [map_sub_swap, map_sub_of_left_eq_zero v hy] | 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_sub_of_right_eq_zero | null |
map_add_of_left_eq_zero (hx : v x = 0) : v (x + y) = v y := by
rw [← sub_neg_eq_add, map_sub_of_left_eq_zero v hx, map_neg] | 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_add_of_left_eq_zero | null |
map_add_of_right_eq_zero (hy : v y = 0) : v (x + y) = v x := by
rw [add_comm, map_add_of_left_eq_zero v hy] | 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_add_of_right_eq_zero | null |
map_one_add_of_lt (h : v x < 1) : v (1 + x) = 1 := by
rw [← v.map_one] at h
simpa only [v.map_one] using v.map_add_eq_of_lt_left 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_one_add_of_lt | null |
map_one_sub_of_lt (h : v x < 1) : v (1 - x) = 1 := by
rw [← v.map_one, ← v.map_neg] at h
rw [sub_eq_add_neg 1 x]
simpa only [v.map_one, v.map_neg] using v.map_add_eq_of_lt_left 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_one_sub_of_lt | null |
congr (f : Γ₀ ≃*o Γ'₀) : Valuation R Γ₀ ≃ Valuation R Γ'₀ where
toFun := map f f.toOrderIso.monotone
invFun := map f.symm f.toOrderIso.symm.monotone
left_inv ν := by ext; simp
right_inv ν := by ext; 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 | congr | An ordered monoid isomorphism `Γ₀ ≃ Γ'₀` induces an equivalence
`Valuation R Γ₀ ≃ Valuation R Γ'₀`. |
protected one : One (Valuation R Γ₀) where
one :=
{ __ : R →*₀ Γ₀ := 1
map_add_le_max' x y := by
simp only [ZeroHom.toFun_eq_coe, MonoidWithZeroHom.toZeroHom_coe,
MonoidWithZeroHom.one_apply_def, le_sup_iff]
split_ifs <;> simp_all } | instance | 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 | one | The trivial valuation, sending everything to 1 other than 0. |
one_apply_def (x : R) : (1 : Valuation R Γ₀) x = if x = 0 then 0 else 1 := rfl
@[simp] lemma toMonoidWithZeroHom_one : (1 : Valuation R Γ₀).toMonoidWithZeroHom = 1 := 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 | one_apply_def | null |
one_apply_of_ne_zero {x : R} (hx : x ≠ 0) : (1 : Valuation R Γ₀) x = 1 := if_neg hx
@[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 | one_apply_of_ne_zero | null |
one_apply_eq_zero_iff [Nontrivial Γ₀] {x : R} : (1 : Valuation R Γ₀) x = 0 ↔ x = 0 :=
MonoidWithZeroHom.one_apply_eq_zero_iff | 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 | one_apply_eq_zero_iff | null |
one_apply_le_one (x : R) : (1 : Valuation R Γ₀) x ≤ 1 := by
rw [one_apply_def]
split_ifs <;> simp_all
@[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 | one_apply_le_one | null |
one_apply_lt_one_iff [Nontrivial Γ₀] {x : R} : (1 : Valuation R Γ₀) x < 1 ↔ x = 0 := by
rw [one_apply_def]
split_ifs <;> simp_all
@[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 | one_apply_lt_one_iff | null |
one_apply_eq_one_iff [Nontrivial Γ₀] {x : R} : (1 : Valuation R Γ₀) x = 1 ↔ x ≠ 0 :=
MonoidWithZeroHom.one_apply_eq_one_iff | 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 | one_apply_eq_one_iff | null |
map_inv {R : Type*} [DivisionRing R] (v : Valuation R Γ₀) : ∀ x, v x⁻¹ = (v x)⁻¹ :=
map_inv₀ _ | 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 {R : Type*} [DivisionRing R] (v : Valuation R Γ₀) : ∀ x y, v (x / y) = v x / v y :=
map_div₀ _ | 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 |
one_lt_val_iff (v : Valuation K Γ₀) {x : K} (h : x ≠ 0) : 1 < v x ↔ v x⁻¹ < 1 := by
simp [inv_lt_one₀ (v.pos_iff.2 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 | one_lt_val_iff | null |
one_le_val_iff (v : Valuation K Γ₀) {x : K} (h : x ≠ 0) : 1 ≤ v x ↔ v x⁻¹ ≤ 1 := by
simp [inv_le_one₀ (v.pos_iff.2 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 | one_le_val_iff | null |
val_lt_one_iff (v : Valuation K Γ₀) {x : K} (h : x ≠ 0) : v x < 1 ↔ 1 < v x⁻¹ := by
simp [one_lt_inv₀ (v.pos_iff.2 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_lt_one_iff | null |
val_le_one_iff (v : Valuation K Γ₀) {x : K} (h : x ≠ 0) : v x ≤ 1 ↔ 1 ≤ v x⁻¹ := by
simp [one_le_inv₀ (v.pos_iff.2 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_le_one_iff | null |
val_eq_one_iff (v : Valuation K Γ₀) {x : K} : v x = 1 ↔ v x⁻¹ = 1 := by
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 | val_eq_one_iff | null |
val_le_one_or_val_inv_lt_one (v : Valuation K Γ₀) (x : K) : v x ≤ 1 ∨ v x⁻¹ < 1 := by
by_cases h : x = 0
· simp only [h, map_zero, zero_le', inv_zero, zero_lt_one, or_self]
· simp only [← one_lt_val_iff v h, le_or_gt] | 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_le_one_or_val_inv_lt_one | null |
val_le_one_or_val_inv_le_one (v : Valuation K Γ₀) (x : K) : v x ≤ 1 ∨ v x⁻¹ ≤ 1 := by
by_cases h : x = 0
· simp only [h, map_zero, zero_le', inv_zero, or_self]
· simp only [← one_le_val_iff v h, le_total] | 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_le_one_or_val_inv_le_one | This theorem is a weaker version of `Valuation.val_le_one_or_val_inv_lt_one`, but more symmetric
in `x` and `x⁻¹`. |
@[simps] ltAddSubgroup (v : Valuation R Γ₀) (γ : Γ₀ˣ) : AddSubgroup R where
carrier := { x | v x < γ }
zero_mem' := by simp
add_mem' {x y} x_in y_in := lt_of_le_of_lt (v.map_add x y) (max_lt x_in y_in)
neg_mem' x_in := by rwa [Set.mem_setOf, map_neg]
@[simp] lemma mem_ltAddSubgroup_iff {v : Valuation R Γ₀} {γ x} :
x ∈ ltAddSubgroup v γ ↔ v x < γ :=
Iff.rfl | 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 | ltAddSubgroup | The subgroup of elements whose valuation is less than a certain unit. |
IsNontrivial : Prop where
exists_val_nontrivial : ∃ x : R, v x ≠ 0 ∧ v x ≠ 1 | class | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | IsNontrivial | A valuation on a ring is nontrivial if there exists an element with valuation
not equal to `0` or `1`. |
IsNontrivial.nontrivial_codomain [hv : IsNontrivial v] :
Nontrivial Γ₀ := by
obtain ⟨x, hx0, hx1⟩ := hv.exists_val_nontrivial
exact ⟨v x, 1, hx1⟩ | 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 | IsNontrivial.nontrivial_codomain | null |
not_isNontrivial_one [IsDomain R] [DecidablePred fun x : R ↦ x = 0] :
¬(1 : Valuation R Γ₀).IsNontrivial := by
rintro ⟨⟨x, hx, hx'⟩⟩
rcases eq_or_ne x 0 with rfl | hx0 <;>
simp_all [one_apply_of_ne_zero] | 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 | not_isNontrivial_one | null |
isNontrivial_iff_exists_unit :
w.IsNontrivial ↔ ∃ x : Kˣ, w x ≠ 1 :=
⟨fun ⟨x, hx0, hx1⟩ ↦
have : Nontrivial Γ₀ := ⟨w x, 0, hx0⟩
⟨Units.mk0 x (w.ne_zero_iff.mp hx0), hx1⟩,
fun ⟨x, hx⟩ ↦
have : Nontrivial Γ₀ := ⟨w x, 1, hx⟩
⟨x, w.ne_zero_iff.mpr (Units.ne_zero x), hx⟩⟩ | 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 | isNontrivial_iff_exists_unit | For fields, being nontrivial is equivalent to the existence of a unit with valuation
not equal to `1`. |
IsNontrivial.exists_lt_one {Γ₀ : Type*} [LinearOrderedCommGroupWithZero Γ₀]
{v : Valuation K Γ₀} [hv : v.IsNontrivial] :
∃ x : K, v x ≠ 0 ∧ v x < 1 := by
obtain ⟨x, hx⟩ := isNontrivial_iff_exists_unit.mp hv
rw [ne_iff_lt_or_gt] at hx
rcases hx with hx | hx
· use x
simp [hx]
· use x⁻¹
simp [- map_inv₀, ← one_lt_val_iff, hx] | 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 | IsNontrivial.exists_lt_one | null |
isNontrivial_iff_exists_lt_one {Γ₀ : Type*}
[LinearOrderedCommGroupWithZero Γ₀] (v : Valuation K Γ₀) :
v.IsNontrivial ↔ ∃ x, x ≠ 0 ∧ v x < 1 :=
⟨fun h ↦ by simpa using h.exists_lt_one (v := v), fun ⟨x, hx0, hx1⟩ ↦ ⟨x, by simp [hx0, hx1.ne]⟩⟩ | 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 | isNontrivial_iff_exists_lt_one | null |
IsNontrivial.exists_one_lt {Γ₀ : Type*} [LinearOrderedCommGroupWithZero Γ₀]
{v : Valuation K Γ₀} [hv : v.IsNontrivial] :
∃ x : K, v x ≠ 0 ∧ 1 < v x := by
obtain ⟨x, h0, h1⟩ := hv.exists_lt_one
use x⁻¹
simp [one_lt_inv₀ (zero_lt_iff.mpr h0), h0, h1] | 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 | IsNontrivial.exists_one_lt | null |
@[refl]
refl : v.IsEquiv v := fun _ _ => Iff.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₁ := fun _ _ => Iff.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₃ := fun _ _ =>
Iff.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' : Valuation R Γ₀} (h : v = v') : v.IsEquiv v' := by subst h; 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 | of_eq | null |
map {v' : Valuation R Γ₀} (f : Γ₀ →*₀ Γ'₀) (hf : Monotone f) (inf : Injective f)
(h : v.IsEquiv v') : (v.map f hf).IsEquiv (v'.map f hf) :=
let H : StrictMono f := hf.strictMono_of_injective inf
fun r s =>
calc
f (v r) ≤ f (v s) ↔ v r ≤ v s := by rw [H.le_iff_le]
_ ↔ v' r ≤ v' s := h r s
_ ↔ f (v' r) ≤ f (v' s) := by rw [H.le_iff_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 | null |
comap {S : Type*} [Ring S] (f : S →+* R) (h : v₁.IsEquiv v₂) :
(v₁.comap f).IsEquiv (v₂.comap f) := fun r s => h (f r) (f s) | 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 := by
simpa only [le_antisymm_iff] using and_congr (h r s) (h s 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 | val_eq | null |
ne_zero (h : v₁.IsEquiv v₂) {r : R} : v₁ r ≠ 0 ↔ v₂ r ≠ 0 := by
have : v₁ r ≠ v₁ 0 ↔ v₂ r ≠ v₂ 0 := not_congr h.val_eq
rwa [v₁.map_zero, v₂.map_zero] at this | 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_zero | null |
lt_iff_lt (h : v₁.IsEquiv v₂) {x y : R} :
v₁ x < v₁ y ↔ v₂ x < v₂ y := by
rw [← le_iff_le_iff_lt_iff_lt, h] | 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 | lt_iff_lt | null |
le_one_iff_le_one (h : v₁.IsEquiv v₂) {x : R} :
v₁ x ≤ 1 ↔ v₂ x ≤ 1 := by
rw [← v₁.map_one, h, map_one] | 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 | le_one_iff_le_one | null |
eq_one_iff_eq_one (h : v₁.IsEquiv v₂) {x : R} :
v₁ x = 1 ↔ v₂ x = 1 := by
rw [← v₁.map_one, h.val_eq, map_one] | 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 | eq_one_iff_eq_one | null |
lt_one_iff_lt_one (h : v₁.IsEquiv v₂) {x : R} :
v₁ x < 1 ↔ v₂ x < 1 := by
rw [← v₁.map_one, h.lt_iff_lt, map_one] | 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 | lt_one_iff_lt_one | null |
isEquiv_of_map_strictMono [LinearOrderedCommMonoidWithZero Γ₀]
[LinearOrderedCommMonoidWithZero Γ'₀] [Ring R] {v : Valuation R Γ₀} (f : Γ₀ →*₀ Γ'₀)
(H : StrictMono f) : IsEquiv (v.map f H.monotone) v := fun _x _y =>
⟨H.le_iff_le.mp, fun h => H.monotone 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 | isEquiv_of_map_strictMono | null |
isEquiv_iff_val_lt_val [LinearOrderedCommMonoidWithZero Γ₀]
[LinearOrderedCommMonoidWithZero Γ'₀] {v : Valuation K Γ₀} {v' : Valuation K Γ'₀} :
v.IsEquiv v' ↔ ∀ {x y : K}, v x < v y ↔ v' x < v' y := by
simp only [IsEquiv, le_iff_le_iff_lt_iff_lt]
exact forall_comm | 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 | isEquiv_iff_val_lt_val | null |
isEquiv_of_val_le_one [LinearOrderedCommGroupWithZero Γ₀]
[LinearOrderedCommGroupWithZero Γ'₀] {v : Valuation K Γ₀} {v' : Valuation K Γ'₀}
(h : ∀ {x : K}, v x ≤ 1 ↔ v' x ≤ 1) : v.IsEquiv v' := by
intro x y
obtain rfl | hy := eq_or_ne y 0
· simp
· rw [← div_le_one₀, ← v.map_div, h, v'.map_div, div_le_one₀] <;>
rwa [zero_lt_iff, 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 | isEquiv_of_val_le_one | null |
isEquiv_iff_val_le_one [LinearOrderedCommGroupWithZero Γ₀]
[LinearOrderedCommGroupWithZero Γ'₀] {v : Valuation K Γ₀} {v' : Valuation K Γ'₀} :
v.IsEquiv v' ↔ ∀ {x : K}, v x ≤ 1 ↔ v' x ≤ 1 :=
⟨IsEquiv.le_one_iff_le_one, isEquiv_of_val_le_one⟩ | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | isEquiv_iff_val_le_one | null |
isEquiv_iff_val_eq_one [LinearOrderedCommGroupWithZero Γ₀]
[LinearOrderedCommGroupWithZero Γ'₀] {v : Valuation K Γ₀} {v' : Valuation K Γ'₀} :
v.IsEquiv v' ↔ ∀ {x : K}, v x = 1 ↔ v' x = 1 := by
constructor
· intro h x
rw [h.eq_one_iff_eq_one]
· intro h
apply isEquiv_of_val_le_one
intro x
constructor
· intro hx
rcases lt_or_eq_of_le hx with hx' | hx'
· have : v (1 + x) = 1 := by
rw [← v.map_one]
apply map_add_eq_of_lt_left
simpa
rw [h] at this
rw [show x = -1 + (1 + x) by simp]
refine le_trans (v'.map_add _ _) ?_
simp [this]
· rw [h] at hx'
exact le_of_eq hx'
· intro hx
rcases lt_or_eq_of_le hx with hx' | hx'
· have : v' (1 + x) = 1 := by
rw [← v'.map_one]
apply map_add_eq_of_lt_left
simpa
rw [← h] at this
rw [show x = -1 + (1 + x) by simp]
refine le_trans (v.map_add _ _) ?_
simp [this]
· rw [← h] at hx'
exact le_of_eq 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 | isEquiv_iff_val_eq_one | null |
isEquiv_iff_val_lt_one [LinearOrderedCommGroupWithZero Γ₀]
[LinearOrderedCommGroupWithZero Γ'₀] {v : Valuation K Γ₀} {v' : Valuation K Γ'₀} :
v.IsEquiv v' ↔ ∀ {x : K}, v x < 1 ↔ v' x < 1 := by
constructor
· intro h x
rw [h.lt_one_iff_lt_one]
· rw [isEquiv_iff_val_eq_one]
intro h x
by_cases hx : x = 0
· simp only [(zero_iff _).2 hx, zero_ne_one]
constructor
· intro hh
by_contra h_1
cases ne_iff_lt_or_gt.1 h_1 with
| inl h_2 => simpa [hh, lt_self_iff_false] using h.2 h_2
| inr h_2 =>
rw [← inv_one, ← inv_eq_iff_eq_inv, ← map_inv₀] at hh
exact hh.not_lt (h.2 ((one_lt_val_iff v' hx).1 h_2))
· intro hh
by_contra h_1
cases ne_iff_lt_or_gt.1 h_1 with
| inl h_2 => simpa [hh, lt_self_iff_false] using h.1 h_2
| inr h_2 =>
rw [← inv_one, ← inv_eq_iff_eq_inv, ← map_inv₀] at hh
exact hh.not_lt (h.1 ((one_lt_val_iff v hx).1 h_2)) | 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 | isEquiv_iff_val_lt_one | null |
isEquiv_iff_val_sub_one_lt_one [LinearOrderedCommGroupWithZero Γ₀]
[LinearOrderedCommGroupWithZero Γ'₀] {v : Valuation K Γ₀} {v' : Valuation K Γ'₀} :
v.IsEquiv v' ↔ ∀ {x : K}, v (x - 1) < 1 ↔ v' (x - 1) < 1 := by
rw [isEquiv_iff_val_lt_one]
exact (Equiv.subRight 1).surjective.forall
alias ⟨IsEquiv.val_sub_one_lt_one_iff, _⟩ := isEquiv_iff_val_sub_one_lt_one | theorem | RingTheory | [
"Mathlib.Algebra.GroupWithZero.Submonoid.Instances",
"Mathlib.Algebra.Order.Hom.Monoid",
"Mathlib.Algebra.Order.Ring.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.Tactic.TFAE"
] | Mathlib/RingTheory/Valuation/Basic.lean | isEquiv_iff_val_sub_one_lt_one | null |
isEquiv_tfae [LinearOrderedCommGroupWithZero Γ₀] [LinearOrderedCommGroupWithZero Γ'₀]
(v : Valuation K Γ₀) (v' : Valuation K Γ'₀) :
[ v.IsEquiv v',
∀ {x y}, v x < v y ↔ v' x < v' y,
∀ {x}, v x ≤ 1 ↔ v' x ≤ 1,
∀ {x}, v x = 1 ↔ v' x = 1,
∀ {x}, v x < 1 ↔ v' x < 1,
∀ {x}, v (x - 1) < 1 ↔ v' (x - 1) < 1 ].TFAE := by
tfae_have 1 ↔ 2 := isEquiv_iff_val_lt_val
tfae_have 1 ↔ 3 := isEquiv_iff_val_le_one
tfae_have 1 ↔ 4 := isEquiv_iff_val_eq_one
tfae_have 1 ↔ 5 := isEquiv_iff_val_lt_one
tfae_have 1 ↔ 6 := isEquiv_iff_val_sub_one_lt_one
tfae_finish | 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 | isEquiv_tfae | null |
supp : Ideal R where
carrier := { x | v x = 0 }
zero_mem' := map_zero v
add_mem' {x y} hx hy := le_zero_iff.mp <|
calc
v (x + y) ≤ max (v x) (v y) := v.map_add x y
_ ≤ 0 := max_le (le_zero_iff.mpr hx) (le_zero_iff.mpr hy)
smul_mem' c x hx :=
calc
v (c * x) = v c * v x := map_mul v c x
_ = v c * 0 := congr_arg _ hx
_ = 0 := mul_zero _
@[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 a valuation `v : R → Γ₀` is the ideal of `R` where `v` vanishes. |
mem_supp_iff (x : R) : x ∈ supp v ↔ v x = 0 :=
Iff.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 | mem_supp_iff | null |
AddValuation :=
Valuation R (Multiplicative Γ₀ᵒᵈ) | 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 | AddValuation | The support of a valuation is a prime ideal. -/
instance [Nontrivial Γ₀] [NoZeroDivisors Γ₀] : Ideal.IsPrime (supp v) :=
⟨fun h =>
one_ne_zero (α := Γ₀) <|
calc
1 = v 1 := v.map_one.symm
_ = 0 := by rw [← mem_supp_iff, h]; exact Submodule.mem_top,
fun {x y} hxy => by
simp only [mem_supp_iff] at hxy ⊢
rw [v.map_mul x y] at hxy
exact eq_zero_or_eq_zero_of_mul_eq_zero hxy⟩
theorem map_add_supp (a : R) {s : R} (h : s ∈ supp v) : v (a + s) = v a := by
have aux : ∀ a s, v s = 0 → v (a + s) ≤ v a := by
intro a' s' h'
refine le_trans (v.map_add a' s') (max_le le_rfl ?_)
simp [h']
apply le_antisymm (aux a s h)
calc
v a = v (a + s + -s) := by simp
_ ≤ v (a + s) := aux (a + s) (-s) (by rwa [← Ideal.neg_mem_iff] at h)
theorem comap_supp {S : Type*} [CommRing S] (f : S →+* R) :
supp (v.comap f) = Ideal.comap f v.supp :=
Ideal.ext fun x => by rw [mem_supp_iff, Ideal.mem_comap, mem_supp_iff, comap_apply]
end Supp
-- end of section
end Valuation
section AddMonoid
variable (R) [Ring R] (Γ₀ : Type*) [LinearOrderedAddCommMonoidWithTop Γ₀]
/-- The type of `Γ₀`-valued additive valuations on `R`. |
of : AddValuation R Γ₀ where
toFun := f
map_one' := h1
map_zero' := h0
map_add_le_max' := hadd
map_mul' := hmul
variable {h0} {h1} {hadd} {hmul} {r : R}
@[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 | of | A valuation is coerced to the underlying function `R → Γ₀`. -/
instance (R) (Γ₀) [Ring R] [LinearOrderedAddCommMonoidWithTop Γ₀] :
FunLike (AddValuation R Γ₀) R Γ₀ where
coe v := v.toMonoidWithZeroHom.toFun
coe_injective' f g := by cases f; cases g; simp +contextual
variable [Ring R] [LinearOrderedAddCommMonoidWithTop Γ₀] [LinearOrderedAddCommMonoidWithTop Γ'₀]
(v : AddValuation R Γ₀)
section
variable (f : R → Γ₀) (h0 : f 0 = ⊤) (h1 : f 1 = 0)
variable (hadd : ∀ x y, min (f x) (f y) ≤ f (x + y)) (hmul : ∀ x y, f (x * y) = f x + f y)
/-- An alternate constructor of `AddValuation`, that doesn't reference `Multiplicative Γ₀ᵒᵈ` |
of_apply : (of f h0 h1 hadd hmul) r = f 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 | of_apply | null |
toValuation : AddValuation R Γ₀ ≃ Valuation R (Multiplicative Γ₀ᵒᵈ) :=
Equiv.refl _ | 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 | toValuation | The `Valuation` associated to an `AddValuation` (useful if the latter is constructed using
`AddValuation.of`). |
ofValuation : Valuation R (Multiplicative Γ₀ᵒᵈ) ≃ AddValuation R Γ₀ :=
Equiv.refl _
@[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 | ofValuation | The `AddValuation` associated to a `Valuation`. |
ofValuation_symm_eq : ofValuation.symm = toValuation (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 | ofValuation_symm_eq | null |
toValuation_symm_eq : toValuation.symm = ofValuation (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 | toValuation_symm_eq | null |
ofValuation_toValuation : ofValuation (toValuation 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 | ofValuation_toValuation | null |
toValuation_ofValuation (v : Valuation R (Multiplicative Γ₀ᵒᵈ)) :
toValuation (ofValuation 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 |
toValuation_apply (r : R) :
toValuation v r = Multiplicative.ofAdd (OrderDual.toDual (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 | toValuation_apply | null |
ofValuation_apply (v : Valuation R (Multiplicative Γ₀ᵒᵈ)) (r : R) :
ofValuation v r = OrderDual.ofDual (Multiplicative.toAdd (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 | ofValuation_apply | null |
@[simp]
map_zero : v 0 = (⊤ : Γ₀) :=
Valuation.map_zero 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_zero | null |
map_one : v 1 = (0 : Γ₀) :=
Valuation.map_one 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_one | null |
@[deprecated "Use `⇑v` instead" (since := "2025-09-04")] asFun : R → Γ₀ := 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 | asFun | A helper function for Lean to inferring types correctly.
Deprecated since it is unused. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.