File: Mathlib/RingTheory/Valuation/ValuationRing.lean

full_name: ValuationRing
code: /-- An integral domain is called a `ValuationRing` provided that for any pair
of elements `a b : A`, either `a` divides `b` or vice versa. -/
class ValuationRing (A : Type u) [CommRing A] [IsDomain A] : Prop where
  cond' : ∀ a b : A, ∃ c : A, a * c = b ∨ b * c = a
goal: Prop

full_name: ValuationRing.cond'
code: /-- An integral domain is called a `ValuationRing` provided that for any pair
of elements `a b : A`, either `a` divides `b` or vice versa. -/
class ValuationRing (A : Type u) [CommRing A] [IsDomain A] : Prop where
  cond' : ∀ a b : A, ∃ c : A, a * c = b ∨ b * c = a
goal: ∃ c, a * c = b ∨ b * c = a

full_name: ValuationRing.cond
code: lemma ValuationRing.cond {A : Type u} [CommRing A] [IsDomain A] [ValuationRing A] (a b : A) :
    ∃ c : A, a * c = b ∨ b * c = a 
goal: ∃ c, a * c = b ∨ b * c = a

full_name: ValuationRing.ValueGroup
code: /-- The value group of the valuation ring `A`. Note: this is actually a group with zero. -/
def ValueGroup : Type v 
goal: Type v

full_name: ValuationRing.instInhabitedValueGroup
code: instance : Inhabited (ValueGroup A K) 
goal: Inhabited (ValuationRing.ValueGroup A K)

full_name: ValuationRing.instLEValueGroup
code: instance : LE (ValueGroup A K) 
goal: LE (ValuationRing.ValueGroup A K)

full_name: ValuationRing.instZeroValueGroup
code: instance : Zero (ValueGroup A K) 
goal: Zero (ValuationRing.ValueGroup A K)

full_name: ValuationRing.instOneValueGroup
code: instance : One (ValueGroup A K) 
goal: One (ValuationRing.ValueGroup A K)

full_name: ValuationRing.instMulValueGroup
code: instance : Mul (ValueGroup A K) 
goal: Mul (ValuationRing.ValueGroup A K)

full_name: ValuationRing.instInvValueGroup
code: instance : Inv (ValueGroup A K) 
goal: Inv (ValuationRing.ValueGroup A K)

full_name: ValuationRing.le_total
code: protected theorem le_total (a b : ValueGroup A K) : a ≤ b ∨ b ≤ a 
goal: a ≤ b ∨ b ≤ a

full_name: ValuationRing.linearOrder
code: noncomputable instance linearOrder : LinearOrder (ValueGroup A K) 
goal: LinearOrder (ValuationRing.ValueGroup A K)

full_name: ValuationRing.linearOrderedCommGroupWithZero
code: noncomputable instance linearOrderedCommGroupWithZero :
    LinearOrderedCommGroupWithZero (ValueGroup A K) 
goal: LinearOrderedCommGroupWithZero (ValuationRing.ValueGroup A K)

full_name: ValuationRing.valuation
code: /-- Any valuation ring induces a valuation on its fraction field. -/
def valuation : Valuation K (ValueGroup A K) 
goal: Valuation K (ValuationRing.ValueGroup A K)

full_name: ValuationRing.mem_integer_iff
code: theorem mem_integer_iff (x : K) : x ∈ (valuation A K).integer ↔ ∃ a : A, algebraMap A K a = x 
goal: x ∈ (ValuationRing.valuation A K).integer ↔ ∃ a, (algebraMap A K) a = x

full_name: ValuationRing.equivInteger
code: /-- The valuation ring `A` is isomorphic to the ring of integers of its associated valuation. -/
noncomputable def equivInteger : A ≃+* (valuation A K).integer 
goal: A ≃+* ↥(ValuationRing.valuation A K).integer

full_name: ValuationRing.coe_equivInteger_apply
code: @[simp]
theorem coe_equivInteger_apply (a : A) : (equivInteger A K a : K) = algebraMap A K a 
goal: ↑((ValuationRing.equivInteger A K) a) = (algebraMap A K) a

full_name: ValuationRing.range_algebraMap_eq
code: theorem range_algebraMap_eq : (valuation A K).integer = (algebraMap A K).range 
goal: (ValuationRing.valuation A K).integer = (algebraMap A K).range

full_name: ValuationRing.localRing
code: instance (priority := 100) localRing : LocalRing A 
goal: LocalRing A

full_name: ValuationRing.instLinearOrderIdealOfDecidableRelLe
code: instance [DecidableRel ((· ≤ ·) : Ideal A → Ideal A → Prop)] : LinearOrder (Ideal A) 
goal: LinearOrder (Ideal A)

full_name: ValuationRing.iff_dvd_total
code: theorem iff_dvd_total : ValuationRing R ↔ IsTotal R (· ∣ ·) 
goal: ValuationRing R ↔ IsTotal R fun x x_1 => x ∣ x_1

full_name: ValuationRing.iff_ideal_total
code: theorem iff_ideal_total : ValuationRing R ↔ IsTotal (Ideal R) (· ≤ ·) 
goal: ValuationRing R ↔ IsTotal (Ideal R) fun x x_1 => x ≤ x_1

full_name: ValuationRing.dvd_total
code: theorem dvd_total [h : ValuationRing R] (x y : R) : x ∣ y ∨ y ∣ x 
goal: x ∣ y ∨ y ∣ x

full_name: ValuationRing.unique_irreducible
code: theorem unique_irreducible [ValuationRing R] ⦃p q : R⦄ (hp : Irreducible p) (hq : Irreducible q) :
    Associated p q 
goal: Associated p q

full_name: ValuationRing.iff_isInteger_or_isInteger
code: theorem iff_isInteger_or_isInteger :
    ValuationRing R ↔ ∀ x : K, IsLocalization.IsInteger R x ∨ IsLocalization.IsInteger R x⁻¹ 
goal: ValuationRing R ↔ ∀ (x : K), IsLocalization.IsInteger R x ∨ IsLocalization.IsInteger R x⁻¹

full_name: ValuationRing.isInteger_or_isInteger
code: theorem isInteger_or_isInteger [h : ValuationRing R] (x : K) :
    IsLocalization.IsInteger R x ∨ IsLocalization.IsInteger R x⁻¹ 
goal: IsLocalization.IsInteger R x ∨ IsLocalization.IsInteger R x⁻¹

full_name: ValuationRing.instIsBezout
code: instance (priority := 100) [ValuationRing R] : IsBezout R 
goal: IsBezout R

full_name: ValuationRing.instOfLocalRingOfIsBezout
code: instance (priority := 100) [LocalRing R] [IsBezout R] : ValuationRing R 
goal: ValuationRing R

full_name: ValuationRing.iff_local_bezout_domain
code: theorem iff_local_bezout_domain : ValuationRing R ↔ LocalRing R ∧ IsBezout R 
goal: ValuationRing R ↔ LocalRing R ∧ IsBezout R

full_name: ValuationRing.TFAE
code: protected theorem TFAE (R : Type u) [CommRing R] [IsDomain R] :
    List.TFAE
      [ValuationRing R,
        ∀ x : FractionRing R, IsLocalization.IsInteger R x ∨ IsLocalization.IsInteger R x⁻¹,
        IsTotal R (· ∣ ·), IsTotal (Ideal R) (· ≤ ·), LocalRing R ∧ IsBezout R] 
goal: [ValuationRing R, ∀ (x : FractionRing R), IsLocalization.IsInteger R x ∨ IsLocalization.IsInteger R x⁻¹,
    IsTotal R fun x x_1 => x ∣ x_1, IsTotal (Ideal R) fun x x_1 => x ≤ x_1, LocalRing R ∧ IsBezout R].TFAE

full_name: Function.Surjective.valuationRing
code: theorem _root_.Function.Surjective.valuationRing {R S : Type*} [CommRing R] [IsDomain R]
    [ValuationRing R] [CommRing S] [IsDomain S] (f : R →+* S) (hf : Function.Surjective f) :
    ValuationRing S 
goal: ValuationRing S

full_name: ValuationRing.of_integers
code: /-- If `𝒪` satisfies `v.integers 𝒪` where `v` is a valuation on a field, then `𝒪`
is a valuation ring. -/
theorem of_integers : ValuationRing 𝒪 
goal: ValuationRing 𝒪

full_name: ValuationRing.instValuationRingInteger
code: instance instValuationRingInteger : ValuationRing v.integer 
goal: ValuationRing ↥v.integer

full_name: ValuationRing.isFractionRing_iff
code: theorem isFractionRing_iff [ValuationRing 𝒪] :
    IsFractionRing 𝒪 K ↔
      (∀ (x : K), ∃ a : 𝒪, x = algebraMap 𝒪 K a ∨ x⁻¹ = algebraMap 𝒪 K a) ∧
        Function.Injective (algebraMap 𝒪 K) 
goal: IsFractionRing 𝒪 K ↔
  (∀ (x : K), ∃ a, x = (algebraMap 𝒪 K) a ∨ x⁻¹ = (algebraMap 𝒪 K) a) ∧ Function.Injective ⇑(algebraMap 𝒪 K)

full_name: ValuationRing.instIsFractionRingInteger
code: instance instIsFractionRingInteger : IsFractionRing v.integer K 
goal: IsFractionRing (↥v.integer) K

full_name: ValuationRing.of_field
code: /-- A field is a valuation ring. -/
instance (priority := 100) of_field : ValuationRing K 
goal: ValuationRing K

full_name: ValuationRing.of_discreteValuationRing
code: /-- A DVR is a valuation ring. -/
instance (priority := 100) of_discreteValuationRing : ValuationRing A 
goal: ValuationRing A