File: Mathlib/RingTheory/Valuation/Basic.lean

full_name: Valuation
code: /-- The type of `Γ₀`-valued valuations on `R`.

When you extend this structure, make sure to extend `ValuationClass`. -/
structure Valuation extends R →*₀ Γ₀ where
  /-- The valuation of a a sum is less that the sum of the valuations -/
  map_add_le_max' : ∀ x y, toFun (x + y) ≤ max (toFun x) (toFun y)
goal: Type (max u_3 u_4)

full_name: Valuation.map_add_le_max'
code: /-- The type of `Γ₀`-valued valuations on `R`.

When you extend this structure, make sure to extend `ValuationClass`. -/
structure Valuation extends R →*₀ Γ₀ where
  /-- The valuation of a a sum is less that the sum of the valuations -/
  map_add_le_max' : ∀ x y, toFun (x + y) ≤ max (toFun x) (toFun y)
goal: (↑self.toMonoidWithZeroHom).toFun (x + y) ≤
  max ((↑self.toMonoidWithZeroHom).toFun x) ((↑self.toMonoidWithZeroHom).toFun y)

full_name: ValuationClass.map_add_le_max
code: /-- `ValuationClass F α β` states that `F` is a type of valuations.

You should also extend this typeclass when you extend `Valuation`. -/
class ValuationClass (F) (R Γ₀ : outParam Type*) [LinearOrderedCommMonoidWithZero Γ₀] [Ring R]
  [FunLike F R Γ₀]
  extends MonoidWithZeroHomClass F R Γ₀ : Prop where
  /-- The valuation of a a sum is less that the sum of the valuations -/
  map_add_le_max (f : F) (x y : R) : f (x + y) ≤ max (f x) (f y)
goal: f (x + y) ≤ max (f x) (f y)

full_name: ValuationClass
code: /-- `ValuationClass F α β` states that `F` is a type of valuations.

You should also extend this typeclass when you extend `Valuation`. -/
class ValuationClass (F) (R Γ₀ : outParam Type*) [LinearOrderedCommMonoidWithZero Γ₀] [Ring R]
  [FunLike F R Γ₀]
  extends MonoidWithZeroHomClass F R Γ₀ : Prop where
  /-- The valuation of a a sum is less that the sum of the valuations -/
  map_add_le_max (f : F) (x y : R) : f (x + y) ≤ max (f x) (f y)
goal: Prop

full_name: instCoeTCValuationOfValuationClass
code: instance [FunLike F R Γ₀] [ValuationClass F R Γ₀] : CoeTC F (Valuation R Γ₀) 
goal: CoeTC F (Valuation R Γ₀)

full_name: Valuation.instFunLike
code: instance : FunLike (Valuation R Γ₀) R Γ₀ 
goal: FunLike (Valuation R Γ₀) R Γ₀

full_name: Valuation.instValuationClass
code: instance : ValuationClass (Valuation R Γ₀) R Γ₀ 
goal: ValuationClass (Valuation R Γ₀) R Γ₀

full_name: Valuation.coe_mk
code: @[simp]
theorem coe_mk (f : R →*₀ Γ₀) (h) : ⇑(Valuation.mk f h) = f 
goal: ⇑{ toMonoidWithZeroHom := f, map_add_le_max' := h } = ⇑f

full_name: Valuation.toFun_eq_coe
code: theorem toFun_eq_coe (v : Valuation R Γ₀) : v.toFun = v 
goal: (↑v.toMonoidWithZeroHom).toFun = ⇑v

full_name: Valuation.toMonoidWithZeroHom_coe_eq_coe
code: @[simp] -- Porting note: requested by simpNF as toFun_eq_coe LHS simplifies
theorem toMonoidWithZeroHom_coe_eq_coe (v : Valuation R Γ₀) :
    (v.toMonoidWithZeroHom : R → Γ₀) = v 
goal: ⇑v.toMonoidWithZeroHom = ⇑v

full_name: Valuation.ext
code: @[ext]
theorem ext {v₁ v₂ : Valuation R Γ₀} (h : ∀ r, v₁ r = v₂ r) : v₁ = v₂ 
goal: v₁ = v₂

full_name: Valuation.coe_coe
code: @[simp, norm_cast]
theorem coe_coe : ⇑(v : R →*₀ Γ₀) = v 
goal: ⇑↑v = ⇑v

full_name: Valuation.map_zero
code: theorem map_zero : v 0 = 0 
goal: v 0 = 0

full_name: Valuation.map_one
code: theorem map_one : v 1 = 1 
goal: v 1 = 1

full_name: Valuation.map_mul
code: theorem map_mul : ∀ x y, v (x * y) = v x * v y 
goal: v (x * y) = v x * v y

full_name: Valuation.map_add
code: theorem map_add : ∀ x y, v (x + y) ≤ max (v x) (v y) 
goal: v (x + y) ≤ max (v x) (v y)

full_name: Valuation.map_add'
code: @[simp]
theorem map_add' : ∀ x y, v (x + y) ≤ v x ∨ v (x + y) ≤ v y 
goal: v (x + y) ≤ v x ∨ v (x + y) ≤ v y

full_name: Valuation.map_add_le
code: theorem map_add_le {x y g} (hx : v x ≤ g) (hy : v y ≤ g) : v (x + y) ≤ g 
goal: v (x + y) ≤ g

full_name: Valuation.map_add_lt
code: theorem map_add_lt {x y g} (hx : v x < g) (hy : v y < g) : v (x + y) < g 
goal: v (x + y) < g

full_name: Valuation.map_sum_le
code: theorem map_sum_le {ι : Type*} {s : Finset ι} {f : ι → R} {g : Γ₀} (hf : ∀ i ∈ s, v (f i) ≤ g) :
    v (∑ i ∈ s, f i) ≤ g 
goal: v (∑ i ∈ s, f i) ≤ g

full_name: Valuation.map_sum_lt
code: theorem 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 
goal: v (∑ i ∈ s, f i) < g

full_name: Valuation.map_sum_lt'
code: theorem 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 
goal: v (∑ i ∈ s, f i) < g

full_name: Valuation.map_pow
code: theorem map_pow : ∀ (x) (n : ℕ), v (x ^ n) = v x ^ n 
goal: v (x ^ n) = v x ^ n

full_name: Valuation.ext_iff
code: /-- Deprecated. Use `DFunLike.ext_iff`. -/
-- @[deprecated] Porting note: using `DFunLike.ext_iff` is not viable below for now
theorem ext_iff {v₁ v₂ : Valuation R Γ₀} : v₁ = v₂ ↔ ∀ r, v₁ r = v₂ r 
goal: v₁ = v₂ ↔ ∀ (r : R), v₁ r = v₂ r

full_name: Valuation.toPreorder
code: /-- A valuation gives a preorder on the underlying ring. -/
def toPreorder : Preorder R 
goal: Preorder R

full_name: Valuation.zero_iff
code: /-- If `v` is a valuation on a division ring then `v(x) = 0` iff `x = 0`. -/
-- @[simp] Porting note (#10618): simp can prove this
theorem zero_iff [Nontrivial Γ₀] (v : Valuation K Γ₀) {x : K} : v x = 0 ↔ x = 0 
goal: v x = 0 ↔ x = 0

full_name: Valuation.ne_zero_iff
code: theorem ne_zero_iff [Nontrivial Γ₀] (v : Valuation K Γ₀) {x : K} : v x ≠ 0 ↔ x ≠ 0 
goal: v x ≠ 0 ↔ x ≠ 0

full_name: Valuation.unit_map_eq
code: theorem unit_map_eq (u : Rˣ) : (Units.map (v : R →* Γ₀) u : Γ₀) = v u 
goal: ↑((Units.map ↑v) u) = v ↑u

full_name: Valuation.comap
code: /-- A ring homomorphism `S → R` induces a map `Valuation R Γ₀ → Valuation S Γ₀`. -/
def comap {S : Type*} [Ring S] (f : S →+* R) (v : Valuation R Γ₀) : Valuation S Γ₀ 
goal: Valuation S Γ₀

full_name: Valuation.comap_apply
code: @[simp]
theorem comap_apply {S : Type*} [Ring S] (f : S →+* R) (v : Valuation R Γ₀) (s : S) :
    v.comap f s = v (f s) 
goal: (Valuation.comap f v) s = v (f s)

full_name: Valuation.comap_id
code: @[simp]
theorem comap_id : v.comap (RingHom.id R) = v 
goal: Valuation.comap (RingHom.id R) v = v

full_name: Valuation.comap_comp
code: theorem 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 
goal: Valuation.comap (g.comp f) v = Valuation.comap f (Valuation.comap g v)

full_name: Valuation.map
code: /-- A `≤`-preserving group homomorphism `Γ₀ → Γ'₀` induces a map `Valuation R Γ₀ → Valuation R Γ'₀`.
-/
def map (f : Γ₀ →*₀ Γ'₀) (hf : Monotone f) (v : Valuation R Γ₀) : Valuation R Γ'₀ 
goal: Valuation R Γ'₀

full_name: Valuation.IsEquiv
code: /-- Two valuations on `R` are defined to be equivalent if they induce the same preorder on `R`. -/
def IsEquiv (v₁ : Valuation R Γ₀) (v₂ : Valuation R Γ'₀) : Prop 
goal: Prop

full_name: Valuation.map_neg
code: @[simp]
theorem map_neg (x : R) : v (-x) = v x 
goal: v (-x) = v x

full_name: Valuation.map_sub_swap
code: theorem map_sub_swap (x y : R) : v (x - y) = v (y - x) 
goal: v (x - y) = v (y - x)

full_name: Valuation.map_inv
code: theorem map_inv {R : Type*} [DivisionRing R] (v : Valuation R Γ₀) : ∀ x, v x⁻¹ = (v x)⁻¹ 
goal: v x⁻¹ = (v x)⁻¹

full_name: Valuation.map_div
code: theorem map_div {R : Type*} [DivisionRing R] (v : Valuation R Γ₀) : ∀ x y, v (x / y) = v x / v y 
goal: v (x / y) = v x / v y

full_name: Valuation.map_sub
code: theorem map_sub (x y : R) : v (x - y) ≤ max (v x) (v y) 
goal: v (x - y) ≤ max (v x) (v y)

full_name: Valuation.map_sub_le
code: theorem map_sub_le {x y g} (hx : v x ≤ g) (hy : v y ≤ g) : v (x - y) ≤ g 
goal: v (x - y) ≤ g

full_name: Valuation.map_add_of_distinct_val
code: theorem map_add_of_distinct_val (h : v x ≠ v y) : v (x + y) = max (v x) (v y) 
goal: v (x + y) = max (v x) (v y)

full_name: Valuation.map_add_eq_of_lt_right
code: theorem map_add_eq_of_lt_right (h : v x < v y) : v (x + y) = v y 
goal: v (x + y) = v y

full_name: Valuation.map_add_eq_of_lt_left
code: theorem map_add_eq_of_lt_left (h : v y < v x) : v (x + y) = v x 
goal: v (x + y) = v x

full_name: Valuation.map_sub_eq_of_lt_right
code: theorem map_sub_eq_of_lt_right (h : v x < v y) : v (x - y) = v y 
goal: v (x - y) = v y

full_name: Valuation.map_sub_eq_of_lt_left
code: theorem map_sub_eq_of_lt_left (h : v y < v x) : v (x - y) = v x 
goal: v (x - y) = v x

full_name: Valuation.map_eq_of_sub_lt
code: theorem map_eq_of_sub_lt (h : v (y - x) < v x) : v y = v x 
goal: v y = v x

full_name: Valuation.map_one_add_of_lt
code: theorem map_one_add_of_lt (h : v x < 1) : v (1 + x) = 1 
goal: v (1 + x) = 1

full_name: Valuation.map_one_sub_of_lt
code: theorem map_one_sub_of_lt (h : v x < 1) : v (1 - x) = 1 
goal: v (1 - x) = 1

full_name: Valuation.one_lt_val_iff
code: theorem one_lt_val_iff (v : Valuation K Γ₀) {x : K} (h : x ≠ 0) : 1 < v x ↔ v x⁻¹ < 1 
goal: 1 < v x ↔ v x⁻¹ < 1

full_name: Valuation.one_le_val_iff
code: theorem one_le_val_iff (v : Valuation K Γ₀) {x : K} (h : x ≠ 0) : 1 ≤ v x ↔ v x⁻¹ ≤ 1 
goal: 1 ≤ v x ↔ v x⁻¹ ≤ 1

full_name: Valuation.val_lt_one_iff
code: theorem val_lt_one_iff (v : Valuation K Γ₀) {x : K} (h : x ≠ 0) : v x < 1 ↔ 1 < v x⁻¹ 
goal: v x < 1 ↔ 1 < v x⁻¹

full_name: Valuation.val_le_one_iff
code: theorem val_le_one_iff (v : Valuation K Γ₀) {x : K} (h : x ≠ 0) : v x ≤ 1 ↔ 1 ≤ v x⁻¹ 
goal: v x ≤ 1 ↔ 1 ≤ v x⁻¹

full_name: Valuation.val_eq_one_iff
code: theorem val_eq_one_iff (v : Valuation K Γ₀) {x : K} : v x = 1 ↔ v x⁻¹ = 1 
goal: v x = 1 ↔ v x⁻¹ = 1

full_name: Valuation.val_le_one_or_val_inv_lt_one
code: theorem val_le_one_or_val_inv_lt_one (v : Valuation K Γ₀) (x : K) : v x ≤ 1 ∨ v x⁻¹ < 1 
goal: v x ≤ 1 ∨ v x⁻¹ < 1

full_name: Valuation.val_le_one_or_val_inv_le_one
code: /--
This theorem is a weaker version of `Valuation.val_le_one_or_val_inv_lt_one`, but more symmetric
in `x` and `x⁻¹`.
-/
theorem val_le_one_or_val_inv_le_one (v : Valuation K Γ₀) (x : K) : v x ≤ 1 ∨ v x⁻¹ ≤ 1 
goal: v x ≤ 1 ∨ v x⁻¹ ≤ 1

full_name: Valuation.ltAddSubgroup
code: /-- The subgroup of elements whose valuation is less than a certain unit. -/
def ltAddSubgroup (v : Valuation R Γ₀) (γ : Γ₀ˣ) : AddSubgroup R 
goal: AddSubgroup R

full_name: Valuation.IsEquiv.refl
code: @[refl]
theorem refl : v.IsEquiv v 
goal: v.IsEquiv v

full_name: Valuation.IsEquiv.symm
code: @[symm]
theorem symm (h : v₁.IsEquiv v₂) : v₂.IsEquiv v₁ 
goal: v₂.IsEquiv v₁

full_name: Valuation.IsEquiv.trans
code: @[trans]
theorem trans (h₁₂ : v₁.IsEquiv v₂) (h₂₃ : v₂.IsEquiv v₃) : v₁.IsEquiv v₃ 
goal: v₁.IsEquiv v₃

full_name: Valuation.IsEquiv.of_eq
code: theorem of_eq {v' : Valuation R Γ₀} (h : v = v') : v.IsEquiv v' 
goal: v.IsEquiv v'

full_name: Valuation.IsEquiv.map
code: theorem map {v' : Valuation R Γ₀} (f : Γ₀ →*₀ Γ'₀) (hf : Monotone f) (inf : Injective f)
    (h : v.IsEquiv v') : (v.map f hf).IsEquiv (v'.map f hf) 
goal: (Valuation.map f hf v).IsEquiv (Valuation.map f hf v')

full_name: Valuation.IsEquiv.comap
code: /-- `comap` preserves equivalence. -/
theorem comap {S : Type*} [Ring S] (f : S →+* R) (h : v₁.IsEquiv v₂) :
    (v₁.comap f).IsEquiv (v₂.comap f) 
goal: (Valuation.comap f v₁).IsEquiv (Valuation.comap f v₂)

full_name: Valuation.IsEquiv.val_eq
code: theorem val_eq (h : v₁.IsEquiv v₂) {r s : R} : v₁ r = v₁ s ↔ v₂ r = v₂ s 
goal: v₁ r = v₁ s ↔ v₂ r = v₂ s

full_name: Valuation.IsEquiv.ne_zero
code: theorem ne_zero (h : v₁.IsEquiv v₂) {r : R} : v₁ r ≠ 0 ↔ v₂ r ≠ 0 
goal: v₁ r ≠ 0 ↔ v₂ r ≠ 0

full_name: Valuation.isEquiv_of_map_strictMono
code: theorem isEquiv_of_map_strictMono [LinearOrderedCommMonoidWithZero Γ₀]
    [LinearOrderedCommMonoidWithZero Γ'₀] [Ring R] {v : Valuation R Γ₀} (f : Γ₀ →*₀ Γ'₀)
    (H : StrictMono f) : IsEquiv (v.map f H.monotone) v 
goal: (Valuation.map f ⋯ v).IsEquiv v

full_name: Valuation.isEquiv_of_val_le_one
code: theorem 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' 
goal: v.IsEquiv v'

full_name: Valuation.isEquiv_iff_val_le_one
code: theorem isEquiv_iff_val_le_one [LinearOrderedCommGroupWithZero Γ₀]
    [LinearOrderedCommGroupWithZero Γ'₀] (v : Valuation K Γ₀) (v' : Valuation K Γ'₀) :
    v.IsEquiv v' ↔ ∀ {x : K}, v x ≤ 1 ↔ v' x ≤ 1 
goal: v.IsEquiv v' ↔ ∀ {x : K}, v x ≤ 1 ↔ v' x ≤ 1

full_name: Valuation.isEquiv_iff_val_eq_one
code: theorem isEquiv_iff_val_eq_one [LinearOrderedCommGroupWithZero Γ₀]
    [LinearOrderedCommGroupWithZero Γ'₀] (v : Valuation K Γ₀) (v' : Valuation K Γ'₀) :
    v.IsEquiv v' ↔ ∀ {x : K}, v x = 1 ↔ v' x = 1 
goal: v.IsEquiv v' ↔ ∀ {x : K}, v x = 1 ↔ v' x = 1

full_name: Valuation.isEquiv_iff_val_lt_one
code: theorem isEquiv_iff_val_lt_one [LinearOrderedCommGroupWithZero Γ₀]
    [LinearOrderedCommGroupWithZero Γ'₀] (v : Valuation K Γ₀) (v' : Valuation K Γ'₀) :
    v.IsEquiv v' ↔ ∀ {x : K}, v x < 1 ↔ v' x < 1 
goal: v.IsEquiv v' ↔ ∀ {x : K}, v x < 1 ↔ v' x < 1

full_name: Valuation.isEquiv_iff_val_sub_one_lt_one
code: theorem 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 
goal: v.IsEquiv v' ↔ ∀ {x : K}, v (x - 1) < 1 ↔ v' (x - 1) < 1

full_name: Valuation.isEquiv_tfae
code: theorem isEquiv_tfae [LinearOrderedCommGroupWithZero Γ₀] [LinearOrderedCommGroupWithZero Γ'₀]
    (v : Valuation K Γ₀) (v' : Valuation K Γ'₀) :
    [v.IsEquiv v', ∀ {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 
goal: [v.IsEquiv v', ∀ {x : K}, v x ≤ 1 ↔ v' x ≤ 1, ∀ {x : K}, v x = 1 ↔ v' x = 1, ∀ {x : K}, v x < 1 ↔ v' x < 1,
    ∀ {x : K}, v (x - 1) < 1 ↔ v' (x - 1) < 1].TFAE

full_name: Valuation.supp
code: /-- The support of a valuation `v : R → Γ₀` is the ideal of `R` where `v` vanishes. -/
def supp : Ideal R 
goal: Ideal R

full_name: Valuation.mem_supp_iff
code: @[simp]
theorem mem_supp_iff (x : R) : x ∈ supp v ↔ v x = 0 
goal: x ∈ v.supp ↔ v x = 0

full_name: Valuation.instIsPrimeSuppOfNontrivialOfNoZeroDivisors
code: /-- The support of a valuation is a prime ideal. -/
instance [Nontrivial Γ₀] [NoZeroDivisors Γ₀] : Ideal.IsPrime (supp v) 
goal: v.supp.IsPrime

full_name: Valuation.map_add_supp
code: theorem map_add_supp (a : R) {s : R} (h : s ∈ supp v) : v (a + s) = v a 
goal: v (a + s) = v a

full_name: Valuation.comap_supp
code: theorem comap_supp {S : Type*} [CommRing S] (f : S →+* R) :
    supp (v.comap f) = Ideal.comap f v.supp 
goal: (Valuation.comap f v).supp = Ideal.comap f v.supp

full_name: AddValuation
code: /-- The type of `Γ₀`-valued additive valuations on `R`. -/
-- porting note (#5171): removed @[nolint has_nonempty_instance]
def AddValuation 
goal: Type (max u_3 u_4)

full_name: AddValuation.instFunLike
code: /-- A valuation is coerced to the underlying function `R → Γ₀`. -/
instance (R) (Γ₀) [Ring R] [LinearOrderedAddCommMonoidWithTop Γ₀] :
    FunLike (AddValuation R Γ₀) R Γ₀ 
goal: FunLike (AddValuation R Γ₀) R Γ₀

full_name: AddValuation.of
code: /-- An alternate constructor of `AddValuation`, that doesn't reference `Multiplicative Γ₀ᵒᵈ` -/
def of : AddValuation R Γ₀ 
goal: AddValuation R Γ₀

full_name: AddValuation.of_apply
code: @[simp]
theorem of_apply : (of f h0 h1 hadd hmul) r = f r 
goal: (AddValuation.of f h0 h1 hadd hmul) r = f r

full_name: AddValuation.valuation
code: /-- The `Valuation` associated to an `AddValuation` (useful if the latter is constructed using
`AddValuation.of`). -/
def valuation : Valuation R (Multiplicative Γ₀ᵒᵈ) 
goal: Valuation R (Multiplicative Γ₀ᵒᵈ)

full_name: AddValuation.valuation_apply
code: @[simp]
theorem valuation_apply (r : R) : v.valuation r = Multiplicative.ofAdd (OrderDual.toDual (v r)) 
goal: v.valuation r = Multiplicative.ofAdd (OrderDual.toDual (v r))

full_name: AddValuation.map_zero
code: @[simp]
theorem map_zero : v 0 = (⊤ : Γ₀) 
goal: v 0 = ⊤

full_name: AddValuation.map_one
code: @[simp]
theorem map_one : v 1 = (0 : Γ₀) 
goal: v 1 = 0

full_name: AddValuation.asFun
code: /-- A helper function for Lean to inferring types correctly -/
def asFun : R → Γ₀ 
goal: R → Γ₀

full_name: AddValuation.map_mul
code: @[simp]
theorem map_mul : ∀ (x y : R), v (x * y) = v x + v y 
goal: v (x * y) = v x + v y

full_name: AddValuation.map_add
code: theorem map_add : ∀ (x y : R), min (v x) (v y) ≤ v (x + y) 
goal: min (v x) (v y) ≤ v (x + y)

full_name: AddValuation.map_add'
code: @[simp]
theorem map_add' : ∀ (x y : R), v x ≤ v (x + y) ∨ v y ≤ v (x + y) 
goal: v x ≤ v (x + y) ∨ v y ≤ v (x + y)

full_name: AddValuation.map_le_add
code: theorem map_le_add {x y : R} {g : Γ₀} (hx : g ≤ v x) (hy : g ≤ v y) : g ≤ v (x + y) 
goal: g ≤ v (x + y)

full_name: AddValuation.map_lt_add
code: theorem map_lt_add {x y : R} {g : Γ₀} (hx : g < v x) (hy : g < v y) : g < v (x + y) 
goal: g < v (x + y)

full_name: AddValuation.map_le_sum
code: theorem map_le_sum {ι : Type*} {s : Finset ι} {f : ι → R} {g : Γ₀} (hf : ∀ i ∈ s, g ≤ v (f i)) :
    g ≤ v (∑ i ∈ s, f i) 
goal: g ≤ v (∑ i ∈ s, f i)

full_name: AddValuation.map_lt_sum
code: theorem map_lt_sum {ι : Type*} {s : Finset ι} {f : ι → R} {g : Γ₀} (hg : g ≠ ⊤)
    (hf : ∀ i ∈ s, g < v (f i)) : g < v (∑ i ∈ s, f i) 
goal: g < v (∑ i ∈ s, f i)

full_name: AddValuation.map_lt_sum'
code: theorem map_lt_sum' {ι : Type*} {s : Finset ι} {f : ι → R} {g : Γ₀} (hg : g < ⊤)
    (hf : ∀ i ∈ s, g < v (f i)) : g < v (∑ i ∈ s, f i) 
goal: g < v (∑ i ∈ s, f i)

full_name: AddValuation.map_pow
code: @[simp]
theorem map_pow : ∀ (x : R) (n : ℕ), v (x ^ n) = n • (v x) 
goal: v (x ^ n) = n • v x

full_name: AddValuation.ext
code: @[ext]
theorem ext {v₁ v₂ : AddValuation R Γ₀} (h : ∀ r, v₁ r = v₂ r) : v₁ = v₂ 
goal: v₁ = v₂

full_name: AddValuation.ext_iff
code: theorem ext_iff {v₁ v₂ : AddValuation R Γ₀} : v₁ = v₂ ↔ ∀ (r : R), v₁ r = v₂ r 
goal: v₁ = v₂ ↔ ∀ (r : R), v₁ r = v₂ r

full_name: AddValuation.toPreorder
code: /-- A valuation gives a preorder on the underlying ring. -/
def toPreorder : Preorder R 
goal: Preorder R

full_name: AddValuation.top_iff
code: /-- If `v` is an additive valuation on a division ring then `v(x) = ⊤` iff `x = 0`. -/
@[simp]
theorem top_iff [Nontrivial Γ₀] (v : AddValuation K Γ₀) {x : K} : v x = (⊤ : Γ₀) ↔ x = 0 
goal: v x = ⊤ ↔ x = 0

full_name: AddValuation.ne_top_iff
code: theorem ne_top_iff [Nontrivial Γ₀] (v : AddValuation K Γ₀) {x : K} : v x ≠ (⊤ : Γ₀) ↔ x ≠ 0 
goal: v x ≠ ⊤ ↔ x ≠ 0

full_name: AddValuation.comap
code: /-- A ring homomorphism `S → R` induces a map `AddValuation R Γ₀ → AddValuation S Γ₀`. -/
def comap {S : Type*} [Ring S] (f : S →+* R) (v : AddValuation R Γ₀) : AddValuation S Γ₀ 
goal: AddValuation S Γ₀

full_name: AddValuation.comap_id
code: @[simp]
theorem comap_id : v.comap (RingHom.id R) = v 
goal: AddValuation.comap (RingHom.id R) v = v

full_name: AddValuation.comap_comp
code: theorem 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 
goal: AddValuation.comap (g.comp f) v = AddValuation.comap f (AddValuation.comap g v)

full_name: AddValuation.map
code: /-- A `≤`-preserving, `⊤`-preserving group homomorphism `Γ₀ → Γ'₀` induces a map
  `AddValuation R Γ₀ → AddValuation R Γ'₀`.
-/
def map (f : Γ₀ →+ Γ'₀) (ht : f ⊤ = ⊤) (hf : Monotone f) (v : AddValuation R Γ₀) :
    AddValuation R Γ'₀ 
goal: AddValuation R Γ'₀

full_name: AddValuation.IsEquiv
code: /-- Two additive valuations on `R` are defined to be equivalent if they induce the same
  preorder on `R`. -/
def IsEquiv (v₁ : AddValuation R Γ₀) (v₂ : AddValuation R Γ'₀) : Prop 
goal: Prop

full_name: AddValuation.map_inv
code: @[simp]
theorem map_inv (v : AddValuation K Γ₀) {x : K} : v x⁻¹ = - (v x) 
goal: v x⁻¹ = -v x

full_name: AddValuation.map_div
code: @[simp]
theorem map_div (v : AddValuation K Γ₀) {x y : K} : v (x / y) = v x - v y 
goal: v (x / y) = v x - v y

full_name: AddValuation.map_neg
code: @[simp]
theorem map_neg (x : R) : v (-x) = v x 
goal: v (-x) = v x

full_name: AddValuation.map_sub_swap
code: theorem map_sub_swap (x y : R) : v (x - y) = v (y - x) 
goal: v (x - y) = v (y - x)

full_name: AddValuation.map_sub
code: theorem map_sub (x y : R) : min (v x) (v y) ≤ v (x - y) 
goal: min (v x) (v y) ≤ v (x - y)

full_name: AddValuation.map_le_sub
code: theorem map_le_sub {x y : R} {g : Γ₀} (hx : g ≤ v x) (hy : g ≤ v y) : g ≤ v (x - y) 
goal: g ≤ v (x - y)

full_name: AddValuation.map_add_of_distinct_val
code: theorem map_add_of_distinct_val (h : v x ≠ v y) : v (x + y) = @Min.min Γ₀ _ (v x) (v y) 
goal: v (x + y) = min (v x) (v y)

full_name: AddValuation.map_add_eq_of_lt_left
code: theorem map_add_eq_of_lt_left {x y : R} (h : v x < v y) :
    v (x + y) = v x 
goal: v (x + y) = v x

full_name: AddValuation.map_add_eq_of_lt_right
code: theorem map_add_eq_of_lt_right {x y : R} (hx : v y < v x) :
    v (x + y) = v y 
goal: v (x + y) = v y

full_name: AddValuation.map_sub_eq_of_lt_left
code: theorem map_sub_eq_of_lt_left {x y : R} (hx : v x < v y) :
    v (x - y) = v x 
goal: v (x - y) = v x

full_name: AddValuation.map_sub_eq_of_lt_right
code: theorem map_sub_eq_of_lt_right {x y : R} (hx : v y < v x) :
    v (x - y) = v y 
goal: v (x - y) = v y

full_name: AddValuation.map_eq_of_lt_sub
code: theorem map_eq_of_lt_sub (h : v x < v (y - x)) : v y = v x 
goal: v y = v x

full_name: AddValuation.IsEquiv.refl
code: @[refl]
theorem refl : v.IsEquiv v 
goal: v.IsEquiv v

full_name: AddValuation.IsEquiv.symm
code: @[symm]
theorem symm (h : v₁.IsEquiv v₂) : v₂.IsEquiv v₁ 
goal: v₂.IsEquiv v₁

full_name: AddValuation.IsEquiv.trans
code: @[trans]
theorem trans (h₁₂ : v₁.IsEquiv v₂) (h₂₃ : v₂.IsEquiv v₃) : v₁.IsEquiv v₃ 
goal: v₁.IsEquiv v₃

full_name: AddValuation.IsEquiv.of_eq
code: theorem of_eq {v' : AddValuation R Γ₀} (h : v = v') : v.IsEquiv v' 
goal: v.IsEquiv v'

full_name: AddValuation.IsEquiv.map
code: theorem 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) 
goal: (AddValuation.map f ht hf v).IsEquiv (AddValuation.map f ht hf v')

full_name: AddValuation.IsEquiv.comap
code: /-- `comap` preserves equivalence. -/
theorem comap {S : Type*} [Ring S] (f : S →+* R) (h : v₁.IsEquiv v₂) :
    (v₁.comap f).IsEquiv (v₂.comap f) 
goal: (AddValuation.comap f v₁).IsEquiv (AddValuation.comap f v₂)

full_name: AddValuation.IsEquiv.val_eq
code: theorem val_eq (h : v₁.IsEquiv v₂) {r s : R} : v₁ r = v₁ s ↔ v₂ r = v₂ s 
goal: v₁ r = v₁ s ↔ v₂ r = v₂ s

full_name: AddValuation.IsEquiv.ne_top
code: theorem ne_top (h : v₁.IsEquiv v₂) {r : R} : v₁ r ≠ (⊤ : Γ₀) ↔ v₂ r ≠ (⊤ : Γ'₀) 
goal: v₁ r ≠ ⊤ ↔ v₂ r ≠ ⊤

full_name: AddValuation.supp
code: /-- The support of an additive valuation `v : R → Γ₀` is the ideal of `R` where `v x = ⊤` -/
def supp : Ideal R 
goal: Ideal R

full_name: AddValuation.mem_supp_iff
code: @[simp]
theorem mem_supp_iff (x : R) : x ∈ supp v ↔ v x = (⊤ : Γ₀) 
goal: x ∈ v.supp ↔ v x = ⊤

full_name: AddValuation.map_add_supp
code: theorem map_add_supp (a : R) {s : R} (h : s ∈ supp v) : v (a + s) = v a 
goal: v (a + s) = v a

full_name: DiscreteValuation._aux_Mathlib_RingTheory_Valuation_Basic___macroRules_DiscreteValuation_termℕₘ₀_1
code: /-- Notation for `WithZero (Multiplicative ℕ)` -/
scoped[DiscreteValuation] notation "ℕₘ₀" => WithZero (Multiplicative ℕ)
goal: Lean.Macro

full_name: DiscreteValuation._aux_Mathlib_RingTheory_Valuation_Basic___unexpand_WithZero_1
code: /-- Notation for `WithZero (Multiplicative ℕ)` -/
scoped[DiscreteValuation] notation "ℕₘ₀" => WithZero (Multiplicative ℕ)
goal: Lean.PrettyPrinter.Unexpander

full_name: DiscreteValuation._aux_Mathlib_RingTheory_Valuation_Basic___unexpand_WithZero_2
code: /-- Notation for `WithZero (Multiplicative ℤ)` -/
scoped[DiscreteValuation] notation "ℤₘ₀" => WithZero (Multiplicative ℤ)
goal: Lean.PrettyPrinter.Unexpander

full_name: DiscreteValuation._aux_Mathlib_RingTheory_Valuation_Basic___macroRules_DiscreteValuation_termℤₘ₀_1
code: /-- Notation for `WithZero (Multiplicative ℤ)` -/
scoped[DiscreteValuation] notation "ℤₘ₀" => WithZero (Multiplicative ℤ)
goal: Lean.Macro