File: Mathlib/RingTheory/DiscreteValuationRing/Basic.lean

full_name: DiscreteValuationRing.not_a_field'
code: /-- An integral domain is a *discrete valuation ring* (DVR) if it's a local PID which
  is not a field. -/
class DiscreteValuationRing (R : Type u) [CommRing R] [IsDomain R]
    extends IsPrincipalIdealRing R, LocalRing R : Prop where
  not_a_field' : maximalIdeal R ≠ ⊥
goal: LocalRing.maximalIdeal R ≠ ⊥

full_name: DiscreteValuationRing
code: /-- An integral domain is a *discrete valuation ring* (DVR) if it's a local PID which
  is not a field. -/
class DiscreteValuationRing (R : Type u) [CommRing R] [IsDomain R]
    extends IsPrincipalIdealRing R, LocalRing R : Prop where
  not_a_field' : maximalIdeal R ≠ ⊥
goal: Prop

full_name: DiscreteValuationRing.not_a_field
code: theorem not_a_field : maximalIdeal R ≠ ⊥ 
goal: LocalRing.maximalIdeal R ≠ ⊥

full_name: DiscreteValuationRing.not_isField
code: /-- A discrete valuation ring `R` is not a field. -/
theorem not_isField : ¬IsField R 
goal: ¬IsField R

full_name: DiscreteValuationRing.irreducible_of_span_eq_maximalIdeal
code: theorem irreducible_of_span_eq_maximalIdeal {R : Type*} [CommRing R] [LocalRing R] [IsDomain R]
    (ϖ : R) (hϖ : ϖ ≠ 0) (h : maximalIdeal R = Ideal.span {ϖ}) : Irreducible ϖ 
goal: Irreducible ϖ

full_name: DiscreteValuationRing.irreducible_iff_uniformizer
code: /-- An element of a DVR is irreducible iff it is a uniformizer, that is, generates the
  maximal ideal of `R`. -/
theorem irreducible_iff_uniformizer (ϖ : R) : Irreducible ϖ ↔ maximalIdeal R = Ideal.span {ϖ} 
goal: Irreducible ϖ ↔ LocalRing.maximalIdeal R = Ideal.span {ϖ}

full_name: Irreducible.maximalIdeal_eq
code: theorem _root_.Irreducible.maximalIdeal_eq {ϖ : R} (h : Irreducible ϖ) :
    maximalIdeal R = Ideal.span {ϖ} 
goal: LocalRing.maximalIdeal R = Ideal.span {ϖ}

full_name: DiscreteValuationRing.exists_irreducible
code: /-- Uniformizers exist in a DVR. -/
theorem exists_irreducible : ∃ ϖ : R, Irreducible ϖ 
goal: ∃ ϖ, Irreducible ϖ

full_name: DiscreteValuationRing.exists_prime
code: /-- Uniformizers exist in a DVR. -/
theorem exists_prime : ∃ ϖ : R, Prime ϖ 
goal: ∃ ϖ, Prime ϖ

full_name: DiscreteValuationRing.iff_pid_with_one_nonzero_prime
code: /-- An integral domain is a DVR iff it's a PID with a unique non-zero prime ideal. -/
theorem iff_pid_with_one_nonzero_prime (R : Type u) [CommRing R] [IsDomain R] :
    DiscreteValuationRing R ↔ IsPrincipalIdealRing R ∧ ∃! P : Ideal R, P ≠ ⊥ ∧ IsPrime P 
goal: DiscreteValuationRing R ↔ IsPrincipalIdealRing R ∧ ∃! P, P ≠ ⊥ ∧ P.IsPrime

full_name: DiscreteValuationRing.associated_of_irreducible
code: theorem associated_of_irreducible {a b : R} (ha : Irreducible a) (hb : Irreducible b) :
    Associated a b 
goal: Associated a b

full_name: DiscreteValuationRing.HasUnitMulPowIrreducibleFactorization
code: /-- Alternative characterisation of discrete valuation rings. -/
def HasUnitMulPowIrreducibleFactorization [CommRing R] : Prop 
goal: Prop

full_name: DiscreteValuationRing.HasUnitMulPowIrreducibleFactorization.unique_irreducible
code: theorem unique_irreducible ⦃p q : R⦄ (hp : Irreducible p) (hq : Irreducible q) :
    Associated p q 
goal: Associated p q

full_name: DiscreteValuationRing.HasUnitMulPowIrreducibleFactorization.toUniqueFactorizationMonoid
code: /-- An integral domain in which there is an irreducible element `p`
such that every nonzero element is associated to a power of `p` is a unique factorization domain.
See `DiscreteValuationRing.ofHasUnitMulPowIrreducibleFactorization`. -/
theorem toUniqueFactorizationMonoid : UniqueFactorizationMonoid R 
goal: UniqueFactorizationMonoid R

full_name: DiscreteValuationRing.HasUnitMulPowIrreducibleFactorization.of_ufd_of_unique_irreducible
code: theorem of_ufd_of_unique_irreducible [UniqueFactorizationMonoid R] (h₁ : ∃ p : R, Irreducible p)
    (h₂ : ∀ ⦃p q : R⦄, Irreducible p → Irreducible q → Associated p q) :
    HasUnitMulPowIrreducibleFactorization R 
goal: DiscreteValuationRing.HasUnitMulPowIrreducibleFactorization R

full_name: DiscreteValuationRing.aux_pid_of_ufd_of_unique_irreducible
code: theorem aux_pid_of_ufd_of_unique_irreducible (R : Type u) [CommRing R] [IsDomain R]
    [UniqueFactorizationMonoid R] (h₁ : ∃ p : R, Irreducible p)
    (h₂ : ∀ ⦃p q : R⦄, Irreducible p → Irreducible q → Associated p q) :
    IsPrincipalIdealRing R 
goal: IsPrincipalIdealRing R

full_name: DiscreteValuationRing.of_ufd_of_unique_irreducible
code: /-- A unique factorization domain with at least one irreducible element
in which all irreducible elements are associated
is a discrete valuation ring.
-/
theorem of_ufd_of_unique_irreducible {R : Type u} [CommRing R] [IsDomain R]
    [UniqueFactorizationMonoid R] (h₁ : ∃ p : R, Irreducible p)
    (h₂ : ∀ ⦃p q : R⦄, Irreducible p → Irreducible q → Associated p q) :
    DiscreteValuationRing R 
goal: DiscreteValuationRing R

full_name: DiscreteValuationRing.ofHasUnitMulPowIrreducibleFactorization
code: /-- An integral domain in which there is an irreducible element `p`
such that every nonzero element is associated to a power of `p`
is a discrete valuation ring.
-/
theorem ofHasUnitMulPowIrreducibleFactorization {R : Type u} [CommRing R] [IsDomain R]
    (hR : HasUnitMulPowIrreducibleFactorization R) : DiscreteValuationRing R 
goal: DiscreteValuationRing R

full_name: DiscreteValuationRing.associated_pow_irreducible
code: theorem associated_pow_irreducible {x : R} (hx : x ≠ 0) {ϖ : R} (hirr : Irreducible ϖ) :
    ∃ n : ℕ, Associated x (ϖ ^ n) 
goal: ∃ n, Associated x (ϖ ^ n)

full_name: DiscreteValuationRing.eq_unit_mul_pow_irreducible
code: theorem eq_unit_mul_pow_irreducible {x : R} (hx : x ≠ 0) {ϖ : R} (hirr : Irreducible ϖ) :
    ∃ (n : ℕ) (u : Rˣ), x = u * ϖ ^ n 
goal: ∃ n u, x = ↑u * ϖ ^ n

full_name: DiscreteValuationRing.ideal_eq_span_pow_irreducible
code: theorem ideal_eq_span_pow_irreducible {s : Ideal R} (hs : s ≠ ⊥) {ϖ : R} (hirr : Irreducible ϖ) :
    ∃ n : ℕ, s = Ideal.span {ϖ ^ n} 
goal: ∃ n, s = Ideal.span {ϖ ^ n}

full_name: DiscreteValuationRing.unit_mul_pow_congr_pow
code: theorem unit_mul_pow_congr_pow {p q : R} (hp : Irreducible p) (hq : Irreducible q) (u v : Rˣ)
    (m n : ℕ) (h : ↑u * p ^ m = v * q ^ n) : m = n 
goal: m = n

full_name: DiscreteValuationRing.unit_mul_pow_congr_unit
code: theorem unit_mul_pow_congr_unit {ϖ : R} (hirr : Irreducible ϖ) (u v : Rˣ) (m n : ℕ)
    (h : ↑u * ϖ ^ m = v * ϖ ^ n) : u = v 
goal: u = v

full_name: DiscreteValuationRing.addVal
code: /-- The `PartENat`-valued additive valuation on a DVR. -/
noncomputable def addVal (R : Type u) [CommRing R] [IsDomain R] [DiscreteValuationRing R] :
    AddValuation R PartENat 
goal: AddValuation R PartENat

full_name: DiscreteValuationRing.addVal_def
code: theorem addVal_def (r : R) (u : Rˣ) {ϖ : R} (hϖ : Irreducible ϖ) (n : ℕ) (hr : r = u * ϖ ^ n) :
    addVal R r = n 
goal: (DiscreteValuationRing.addVal R) r = ↑n

full_name: DiscreteValuationRing.addVal_def'
code: theorem addVal_def' (u : Rˣ) {ϖ : R} (hϖ : Irreducible ϖ) (n : ℕ) :
    addVal R ((u : R) * ϖ ^ n) = n 
goal: (DiscreteValuationRing.addVal R) (↑u * ϖ ^ n) = ↑n

full_name: DiscreteValuationRing.addVal_zero
code: theorem addVal_zero : addVal R 0 = ⊤ 
goal: (DiscreteValuationRing.addVal R) 0 = ⊤

full_name: DiscreteValuationRing.addVal_one
code: theorem addVal_one : addVal R 1 = 0 
goal: (DiscreteValuationRing.addVal R) 1 = 0

full_name: DiscreteValuationRing.addVal_uniformizer
code: @[simp]
theorem addVal_uniformizer {ϖ : R} (hϖ : Irreducible ϖ) : addVal R ϖ = 1 
goal: (DiscreteValuationRing.addVal R) ϖ = 1

full_name: DiscreteValuationRing.addVal_mul
code: theorem addVal_mul {a b : R} :
    addVal R (a * b) = addVal R a + addVal R b 
goal: (DiscreteValuationRing.addVal R) (a * b) = (DiscreteValuationRing.addVal R) a + (DiscreteValuationRing.addVal R) b

full_name: DiscreteValuationRing.addVal_pow
code: theorem addVal_pow (a : R) (n : ℕ) : addVal R (a ^ n) = n • addVal R a 
goal: (DiscreteValuationRing.addVal R) (a ^ n) = n • (DiscreteValuationRing.addVal R) a

full_name: Irreducible.addVal_pow
code: nonrec theorem _root_.Irreducible.addVal_pow {ϖ : R} (h : Irreducible ϖ) (n : ℕ) :
    addVal R (ϖ ^ n) = n 
goal: (DiscreteValuationRing.addVal R) (ϖ ^ n) = ↑n

full_name: DiscreteValuationRing.addVal_eq_top_iff
code: theorem addVal_eq_top_iff {a : R} : addVal R a = ⊤ ↔ a = 0 
goal: (DiscreteValuationRing.addVal R) a = ⊤ ↔ a = 0

full_name: DiscreteValuationRing.addVal_le_iff_dvd
code: theorem addVal_le_iff_dvd {a b : R} : addVal R a ≤ addVal R b ↔ a ∣ b 
goal: (DiscreteValuationRing.addVal R) a ≤ (DiscreteValuationRing.addVal R) b ↔ a ∣ b

full_name: DiscreteValuationRing.addVal_add
code: theorem addVal_add {a b : R} : min (addVal R a) (addVal R b) ≤ addVal R (a + b) 
goal: min ((DiscreteValuationRing.addVal R) a) ((DiscreteValuationRing.addVal R) b) ≤ (DiscreteValuationRing.addVal R) (a + b)

full_name: DiscreteValuationRing.instIsHausdorffMaximalIdeal
code: instance (R : Type*) [CommRing R] [IsDomain R] [DiscreteValuationRing R] :
    IsHausdorff (maximalIdeal R) R 
goal: IsHausdorff (LocalRing.maximalIdeal R) R