File: Mathlib/RingTheory/Valuation/ValuationSubring.lean

full_name: ValuationSubring.mem_or_inv_mem'
code: /-- A valuation subring of a field `K` is a subring `A` such that for every `x : K`,
either `x ∈ A` or `x⁻¹ ∈ A`. -/
structure ValuationSubring extends Subring K where
  mem_or_inv_mem' : ∀ x : K, x ∈ carrier ∨ x⁻¹ ∈ carrier
goal: x ∈ self.carrier ∨ x⁻¹ ∈ self.carrier

full_name: ValuationSubring
code: /-- A valuation subring of a field `K` is a subring `A` such that for every `x : K`,
either `x ∈ A` or `x⁻¹ ∈ A`. -/
structure ValuationSubring extends Subring K where
  mem_or_inv_mem' : ∀ x : K, x ∈ carrier ∨ x⁻¹ ∈ carrier
goal: Type u

full_name: ValuationSubring.instSetLike
code: instance : SetLike (ValuationSubring K) K 
goal: SetLike (ValuationSubring K) K

full_name: ValuationSubring.mem_carrier
code: @[simp, nolint simpNF] -- Porting note (#10959): simp cannot prove that
theorem mem_carrier (x : K) : x ∈ A.carrier ↔ x ∈ A 
goal: x ∈ A.carrier ↔ x ∈ A

full_name: ValuationSubring.mem_toSubring
code: @[simp]
theorem mem_toSubring (x : K) : x ∈ A.toSubring ↔ x ∈ A 
goal: x ∈ A.toSubring ↔ x ∈ A

full_name: ValuationSubring.ext
code: @[ext]
theorem ext (A B : ValuationSubring K) (h : ∀ x, x ∈ A ↔ x ∈ B) : A = B 
goal: A = B

full_name: ValuationSubring.zero_mem
code: theorem zero_mem : (0 : K) ∈ A 
goal: 0 ∈ A

full_name: ValuationSubring.one_mem
code: theorem one_mem : (1 : K) ∈ A 
goal: 1 ∈ A

full_name: ValuationSubring.add_mem
code: theorem add_mem (x y : K) : x ∈ A → y ∈ A → x + y ∈ A 
goal: x ∈ A → y ∈ A → x + y ∈ A

full_name: ValuationSubring.mul_mem
code: theorem mul_mem (x y : K) : x ∈ A → y ∈ A → x * y ∈ A 
goal: x ∈ A → y ∈ A → x * y ∈ A

full_name: ValuationSubring.neg_mem
code: theorem neg_mem (x : K) : x ∈ A → -x ∈ A 
goal: x ∈ A → -x ∈ A

full_name: ValuationSubring.mem_or_inv_mem
code: theorem mem_or_inv_mem (x : K) : x ∈ A ∨ x⁻¹ ∈ A 
goal: x ∈ A ∨ x⁻¹ ∈ A

full_name: ValuationSubring.instSubringClass
code: instance : SubringClass (ValuationSubring K) K 
goal: SubringClass (ValuationSubring K) K

full_name: ValuationSubring.toSubring_injective
code: theorem toSubring_injective : Function.Injective (toSubring : ValuationSubring K → Subring K) 
goal: Function.Injective ValuationSubring.toSubring

full_name: ValuationSubring.instCommRingSubtypeMem
code: instance : CommRing A 
goal: CommRing ↥A

full_name: ValuationSubring.instIsDomainSubtypeMem
code: instance : IsDomain A 
goal: IsDomain ↥A

full_name: ValuationSubring.instTop
code: instance : Top (ValuationSubring K) 
goal: Top (ValuationSubring K)

full_name: ValuationSubring.mem_top
code: theorem mem_top (x : K) : x ∈ (⊤ : ValuationSubring K) 
goal: x ∈ ⊤

full_name: ValuationSubring.le_top
code: theorem le_top : A ≤ ⊤ 
goal: A ≤ ⊤

full_name: ValuationSubring.instOrderTop
code: instance : OrderTop (ValuationSubring K) 
goal: OrderTop (ValuationSubring K)

full_name: ValuationSubring.instInhabited
code: instance : Inhabited (ValuationSubring K) 
goal: Inhabited (ValuationSubring K)

full_name: ValuationSubring.instValuationRingSubtypeMem
code: instance : ValuationRing A 
goal: ValuationRing ↥A

full_name: ValuationSubring.instAlgebraSubtypeMem
code: instance : Algebra A K 
goal: Algebra (↥A) K

full_name: ValuationSubring.localRing
code: instance localRing : LocalRing A 
goal: LocalRing ↥A

full_name: ValuationSubring.algebraMap_apply
code: @[simp]
theorem algebraMap_apply (a : A) : algebraMap A K a = a 
goal: (algebraMap (↥A) K) a = ↑a

full_name: ValuationSubring.instIsFractionRingSubtypeMem
code: instance : IsFractionRing A K 
goal: IsFractionRing (↥A) K

full_name: ValuationSubring.ValueGroup
code: /-- The value group of the valuation associated to `A`. Note: it is actually a group with zero. -/
def ValueGroup 
goal: Type u

full_name: ValuationSubring.instLinearOrderedCommGroupWithZeroValueGroup
code: instance : LinearOrderedCommGroupWithZero (ValueGroup A) 
goal: LinearOrderedCommGroupWithZero A.ValueGroup

full_name: ValuationSubring.valuation
code: /-- Any valuation subring of `K` induces a natural valuation on `K`. -/
def valuation : Valuation K A.ValueGroup 
goal: Valuation K A.ValueGroup

full_name: ValuationSubring.inhabitedValueGroup
code: instance inhabitedValueGroup : Inhabited A.ValueGroup 
goal: Inhabited A.ValueGroup

full_name: ValuationSubring.valuation_le_one
code: theorem valuation_le_one (a : A) : A.valuation a ≤ 1 
goal: A.valuation ↑a ≤ 1

full_name: ValuationSubring.mem_of_valuation_le_one
code: theorem mem_of_valuation_le_one (x : K) (h : A.valuation x ≤ 1) : x ∈ A 
goal: x ∈ A

full_name: ValuationSubring.valuation_le_one_iff
code: theorem valuation_le_one_iff (x : K) : A.valuation x ≤ 1 ↔ x ∈ A 
goal: A.valuation x ≤ 1 ↔ x ∈ A

full_name: ValuationSubring.valuation_eq_iff
code: theorem valuation_eq_iff (x y : K) : A.valuation x = A.valuation y ↔ ∃ a : Aˣ, (a : K) * y = x 
goal: A.valuation x = A.valuation y ↔ ∃ a, ↑↑a * y = x

full_name: ValuationSubring.valuation_le_iff
code: theorem valuation_le_iff (x y : K) : A.valuation x ≤ A.valuation y ↔ ∃ a : A, (a : K) * y = x 
goal: A.valuation x ≤ A.valuation y ↔ ∃ a, ↑a * y = x

full_name: ValuationSubring.valuation_surjective
code: theorem valuation_surjective : Function.Surjective A.valuation 
goal: Function.Surjective ⇑A.valuation

full_name: ValuationSubring.valuation_unit
code: theorem valuation_unit (a : Aˣ) : A.valuation a = 1 
goal: A.valuation ↑↑a = 1

full_name: ValuationSubring.valuation_eq_one_iff
code: theorem valuation_eq_one_iff (a : A) : IsUnit a ↔ A.valuation a = 1 
goal: IsUnit a ↔ A.valuation ↑a = 1

full_name: ValuationSubring.valuation_lt_one_or_eq_one
code: theorem valuation_lt_one_or_eq_one (a : A) : A.valuation a < 1 ∨ A.valuation a = 1 
goal: A.valuation ↑a < 1 ∨ A.valuation ↑a = 1

full_name: ValuationSubring.valuation_lt_one_iff
code: theorem valuation_lt_one_iff (a : A) : a ∈ LocalRing.maximalIdeal A ↔ A.valuation a < 1 
goal: a ∈ LocalRing.maximalIdeal ↥A ↔ A.valuation ↑a < 1

full_name: ValuationSubring.ofSubring
code: /-- A subring `R` of `K` such that for all `x : K` either `x ∈ R` or `x⁻¹ ∈ R` is
  a valuation subring of `K`. -/
def ofSubring (R : Subring K) (hR : ∀ x : K, x ∈ R ∨ x⁻¹ ∈ R) : ValuationSubring K 
goal: ValuationSubring K

full_name: ValuationSubring.mem_ofSubring
code: @[simp]
theorem mem_ofSubring (R : Subring K) (hR : ∀ x : K, x ∈ R ∨ x⁻¹ ∈ R) (x : K) :
    x ∈ ofSubring R hR ↔ x ∈ R 
goal: x ∈ ValuationSubring.ofSubring R hR ↔ x ∈ R

full_name: ValuationSubring.ofLE
code: /-- An overring of a valuation ring is a valuation ring. -/
def ofLE (R : ValuationSubring K) (S : Subring K) (h : R.toSubring ≤ S) : ValuationSubring K 
goal: ValuationSubring K

full_name: ValuationSubring.instSemilatticeSup
code: instance : SemilatticeSup (ValuationSubring K) 
goal: SemilatticeSup (ValuationSubring K)

full_name: ValuationSubring.inclusion
code: /-- The ring homomorphism induced by the partial order. -/
def inclusion (R S : ValuationSubring K) (h : R ≤ S) : R →+* S 
goal: ↥R →+* ↥S

full_name: ValuationSubring.subtype
code: /-- The canonical ring homomorphism from a valuation ring to its field of fractions. -/
def subtype (R : ValuationSubring K) : R →+* K 
goal: ↥R →+* K

full_name: ValuationSubring.mapOfLE
code: /-- The canonical map on value groups induced by a coarsening of valuation rings. -/
def mapOfLE (R S : ValuationSubring K) (h : R ≤ S) : R.ValueGroup →*₀ S.ValueGroup 
goal: R.ValueGroup →*₀ S.ValueGroup

full_name: ValuationSubring.monotone_mapOfLE
code: @[mono]
theorem monotone_mapOfLE (R S : ValuationSubring K) (h : R ≤ S) : Monotone (R.mapOfLE S h) 
goal: Monotone ⇑(R.mapOfLE S h)

full_name: ValuationSubring.mapOfLE_comp_valuation
code: @[simp]
theorem mapOfLE_comp_valuation (R S : ValuationSubring K) (h : R ≤ S) :
    R.mapOfLE S h ∘ R.valuation = S.valuation 
goal: ⇑(R.mapOfLE S h) ∘ ⇑R.valuation = ⇑S.valuation

full_name: ValuationSubring.mapOfLE_valuation_apply
code: @[simp]
theorem mapOfLE_valuation_apply (R S : ValuationSubring K) (h : R ≤ S) (x : K) :
    R.mapOfLE S h (R.valuation x) = S.valuation x 
goal: (R.mapOfLE S h) (R.valuation x) = S.valuation x

full_name: ValuationSubring.idealOfLE
code: /-- The ideal corresponding to a coarsening of a valuation ring. -/
def idealOfLE (R S : ValuationSubring K) (h : R ≤ S) : Ideal R 
goal: Ideal ↥R

full_name: ValuationSubring.prime_idealOfLE
code: instance prime_idealOfLE (R S : ValuationSubring K) (h : R ≤ S) : (idealOfLE R S h).IsPrime 
goal: (R.idealOfLE S h).IsPrime

full_name: ValuationSubring.ofPrime
code: /-- The coarsening of a valuation ring associated to a prime ideal. -/
def ofPrime (A : ValuationSubring K) (P : Ideal A) [P.IsPrime] : ValuationSubring K 
goal: ValuationSubring K

full_name: ValuationSubring.ofPrimeAlgebra
code: instance ofPrimeAlgebra (A : ValuationSubring K) (P : Ideal A) [P.IsPrime] :
    Algebra A (A.ofPrime P) 
goal: Algebra ↥A ↥(A.ofPrime P)

full_name: ValuationSubring.ofPrime_scalar_tower
code: instance ofPrime_scalar_tower (A : ValuationSubring K) (P : Ideal A) [P.IsPrime] :
    -- porting note (#10754): added instance
    letI : SMul A (A.ofPrime P) := SMulZeroClass.toSMul
    IsScalarTower A (A.ofPrime P) K 
goal: IsScalarTower (↥A) (↥(A.ofPrime P)) K

full_name: ValuationSubring.ofPrime_localization
code: instance ofPrime_localization (A : ValuationSubring K) (P : Ideal A) [P.IsPrime] :
    IsLocalization.AtPrime (A.ofPrime P) P 
goal: IsLocalization.AtPrime (↥(A.ofPrime P)) P

full_name: ValuationSubring.le_ofPrime
code: theorem le_ofPrime (A : ValuationSubring K) (P : Ideal A) [P.IsPrime] : A ≤ ofPrime A P 
goal: A ≤ A.ofPrime P

full_name: ValuationSubring.ofPrime_valuation_eq_one_iff_mem_primeCompl
code: theorem ofPrime_valuation_eq_one_iff_mem_primeCompl (A : ValuationSubring K) (P : Ideal A)
    [P.IsPrime] (x : A) : (ofPrime A P).valuation x = 1 ↔ x ∈ P.primeCompl 
goal: (A.ofPrime P).valuation ↑x = 1 ↔ x ∈ P.primeCompl

full_name: ValuationSubring.idealOfLE_ofPrime
code: @[simp]
theorem idealOfLE_ofPrime (A : ValuationSubring K) (P : Ideal A) [P.IsPrime] :
    idealOfLE A (ofPrime A P) (le_ofPrime A P) = P 
goal: A.idealOfLE (A.ofPrime P) ⋯ = P

full_name: ValuationSubring.ofPrime_idealOfLE
code: @[simp]
theorem ofPrime_idealOfLE (R S : ValuationSubring K) (h : R ≤ S) :
    ofPrime R (idealOfLE R S h) = S 
goal: R.ofPrime (R.idealOfLE S h) = S

full_name: ValuationSubring.ofPrime_le_of_le
code: theorem ofPrime_le_of_le (P Q : Ideal A) [P.IsPrime] [Q.IsPrime] (h : P ≤ Q) :
    ofPrime A Q ≤ ofPrime A P 
goal: A.ofPrime Q ≤ A.ofPrime P

full_name: ValuationSubring.idealOfLE_le_of_le
code: theorem idealOfLE_le_of_le (R S : ValuationSubring K) (hR : A ≤ R) (hS : A ≤ S) (h : R ≤ S) :
    idealOfLE A S hS ≤ idealOfLE A R hR 
goal: A.idealOfLE S hS ≤ A.idealOfLE R hR

full_name: ValuationSubring.primeSpectrumEquiv_apply_coe
code: /-- The equivalence between coarsenings of a valuation ring and its prime ideals. -/
@[simps]
def primeSpectrumEquiv : PrimeSpectrum A ≃ {S // A ≤ S} 
goal: ↑(A.primeSpectrumEquiv P) = A.ofPrime P.asIdeal

full_name: ValuationSubring.primeSpectrumEquiv_symm_apply_asIdeal
code: /-- The equivalence between coarsenings of a valuation ring and its prime ideals. -/
@[simps]
def primeSpectrumEquiv : PrimeSpectrum A ≃ {S // A ≤ S} 
goal: (A.primeSpectrumEquiv.symm S).asIdeal = A.idealOfLE ↑S ⋯

full_name: ValuationSubring.primeSpectrumEquiv
code: /-- The equivalence between coarsenings of a valuation ring and its prime ideals. -/
@[simps]
def primeSpectrumEquiv : PrimeSpectrum A ≃ {S // A ≤ S} 
goal: PrimeSpectrum ↥A ≃ { S // A ≤ S }

full_name: ValuationSubring.primeSpectrumOrderEquiv
code: /-- An ordered variant of `primeSpectrumEquiv`. -/
@[simps!]
def primeSpectrumOrderEquiv : (PrimeSpectrum A)ᵒᵈ ≃o {S // A ≤ S} 
goal: (PrimeSpectrum ↥A)ᵒᵈ ≃o { S // A ≤ S }

full_name: ValuationSubring.primeSpectrumOrderEquiv_apply_coe_carrier
code: /-- An ordered variant of `primeSpectrumEquiv`. -/
@[simps!]
def primeSpectrumOrderEquiv : (PrimeSpectrum A)ᵒᵈ ≃o {S // A ≤ S} 
goal: ↑↑(A.primeSpectrumOrderEquiv P) =
  {x | ∃ a ∈ A, ∃ a_1, (∃ (x : a_1 ∈ A), ⟨a_1, ⋯⟩ ∈ P.asIdeal.primeCompl) ∧ x = a * a_1⁻¹}

full_name: ValuationSubring.primeSpectrumOrderEquiv_symm_apply_asIdeal_carrier
code: /-- An ordered variant of `primeSpectrumEquiv`. -/
@[simps!]
def primeSpectrumOrderEquiv : (PrimeSpectrum A)ᵒᵈ ≃o {S // A ≤ S} 
goal: ↑((RelIso.symm A.primeSpectrumOrderEquiv) S).asIdeal = ⇑(A.inclusion ↑S ⋯) ⁻¹' ↑(LocalRing.maximalIdeal ↥↑S)

full_name: ValuationSubring.linearOrderOverring
code: instance linearOrderOverring : LinearOrder {S // A ≤ S} 
goal: LinearOrder { S // A ≤ S }

full_name: Valuation.valuationSubring
code: /-- The valuation subring associated to a valuation. -/
def valuationSubring : ValuationSubring K 
goal: ValuationSubring K

full_name: Valuation.mem_valuationSubring_iff
code: @[simp]
theorem mem_valuationSubring_iff (x : K) : x ∈ v.valuationSubring ↔ v x ≤ 1 
goal: x ∈ v.valuationSubring ↔ v x ≤ 1

full_name: Valuation.isEquiv_iff_valuationSubring
code: theorem isEquiv_iff_valuationSubring :
    v₁.IsEquiv v₂ ↔ v₁.valuationSubring = v₂.valuationSubring 
goal: v₁.IsEquiv v₂ ↔ v₁.valuationSubring = v₂.valuationSubring

full_name: Valuation.isEquiv_valuation_valuationSubring
code: theorem isEquiv_valuation_valuationSubring : v.IsEquiv v.valuationSubring.valuation 
goal: v.IsEquiv v.valuationSubring.valuation

full_name: ValuationSubring.valuationSubring_valuation
code: @[simp]
theorem valuationSubring_valuation : A.valuation.valuationSubring = A 
goal: A.valuation.valuationSubring = A

full_name: ValuationSubring.unitGroup
code: /-- The unit group of a valuation subring, as a subgroup of `Kˣ`. -/
def unitGroup : Subgroup Kˣ 
goal: Subgroup Kˣ

full_name: ValuationSubring.mem_unitGroup_iff
code: @[simp]
theorem mem_unitGroup_iff (x : Kˣ) : x ∈ A.unitGroup ↔ A.valuation x = 1 
goal: x ∈ A.unitGroup ↔ A.valuation ↑x = 1

full_name: ValuationSubring.unitGroupMulEquiv
code: /-- For a valuation subring `A`, `A.unitGroup` agrees with the units of `A`. -/
def unitGroupMulEquiv : A.unitGroup ≃* Aˣ 
goal: ↥A.unitGroup ≃* (↥A)ˣ

full_name: ValuationSubring.coe_unitGroupMulEquiv_apply
code: @[simp]
theorem coe_unitGroupMulEquiv_apply (a : A.unitGroup) :
    ((A.unitGroupMulEquiv a : A) : K) = ((a : Kˣ) : K) 
goal: ↑↑(A.unitGroupMulEquiv a) = ↑↑a

full_name: ValuationSubring.coe_unitGroupMulEquiv_symm_apply
code: @[simp]
theorem coe_unitGroupMulEquiv_symm_apply (a : Aˣ) : ((A.unitGroupMulEquiv.symm a : Kˣ) : K) = a 
goal: ↑↑(A.unitGroupMulEquiv.symm a) = ↑↑a

full_name: ValuationSubring.unitGroup_le_unitGroup
code: theorem unitGroup_le_unitGroup {A B : ValuationSubring K} : A.unitGroup ≤ B.unitGroup ↔ A ≤ B 
goal: A.unitGroup ≤ B.unitGroup ↔ A ≤ B

full_name: ValuationSubring.unitGroup_injective
code: theorem unitGroup_injective : Function.Injective (unitGroup : ValuationSubring K → Subgroup _) 
goal: Function.Injective ValuationSubring.unitGroup

full_name: ValuationSubring.eq_iff_unitGroup
code: theorem eq_iff_unitGroup {A B : ValuationSubring K} : A = B ↔ A.unitGroup = B.unitGroup 
goal: A = B ↔ A.unitGroup = B.unitGroup

full_name: ValuationSubring.unitGroupOrderEmbedding
code: /-- The map on valuation subrings to their unit groups is an order embedding. -/
def unitGroupOrderEmbedding : ValuationSubring K ↪o Subgroup Kˣ 
goal: ValuationSubring K ↪o Subgroup Kˣ

full_name: ValuationSubring.unitGroup_strictMono
code: theorem unitGroup_strictMono : StrictMono (unitGroup : ValuationSubring K → Subgroup _) 
goal: StrictMono ValuationSubring.unitGroup

full_name: ValuationSubring.nonunits
code: /-- The nonunits of a valuation subring of `K`, as a subsemigroup of `K`-/
def nonunits : Subsemigroup K 
goal: Subsemigroup K

full_name: ValuationSubring.mem_nonunits_iff
code: theorem mem_nonunits_iff {x : K} : x ∈ A.nonunits ↔ A.valuation x < 1 
goal: x ∈ A.nonunits ↔ A.valuation x < 1

full_name: ValuationSubring.nonunits_le_nonunits
code: theorem nonunits_le_nonunits {A B : ValuationSubring K} : B.nonunits ≤ A.nonunits ↔ A ≤ B 
goal: B.nonunits ≤ A.nonunits ↔ A ≤ B

full_name: ValuationSubring.nonunits_injective
code: theorem nonunits_injective : Function.Injective (nonunits : ValuationSubring K → Subsemigroup _) 
goal: Function.Injective ValuationSubring.nonunits

full_name: ValuationSubring.nonunits_inj
code: theorem nonunits_inj {A B : ValuationSubring K} : A.nonunits = B.nonunits ↔ A = B 
goal: A.nonunits = B.nonunits ↔ A = B

full_name: ValuationSubring.nonunitsOrderEmbedding
code: /-- The map on valuation subrings to their nonunits is a dual order embedding. -/
def nonunitsOrderEmbedding : ValuationSubring K ↪o (Subsemigroup K)ᵒᵈ 
goal: ValuationSubring K ↪o (Subsemigroup K)ᵒᵈ

full_name: ValuationSubring.coe_mem_nonunits_iff
code: /-- The elements of `A.nonunits` are those of the maximal ideal of `A` after coercion to `K`.

See also `mem_nonunits_iff_exists_mem_maximalIdeal`, which gets rid of the coercion to `K`,
at the expense of a more complicated right hand side.
 -/
theorem coe_mem_nonunits_iff {a : A} : (a : K) ∈ A.nonunits ↔ a ∈ LocalRing.maximalIdeal A 
goal: ↑a ∈ A.nonunits ↔ a ∈ LocalRing.maximalIdeal ↥A

full_name: ValuationSubring.nonunits_le
code: theorem nonunits_le : A.nonunits ≤ A.toSubring.toSubmonoid.toSubsemigroup 
goal: A.nonunits ≤ A.toSubsemigroup

full_name: ValuationSubring.nonunits_subset
code: theorem nonunits_subset : (A.nonunits : Set K) ⊆ A 
goal: ↑A.nonunits ⊆ ↑A

full_name: ValuationSubring.mem_nonunits_iff_exists_mem_maximalIdeal
code: /-- The elements of `A.nonunits` are those of the maximal ideal of `A`.

See also `coe_mem_nonunits_iff`, which has a simpler right hand side but requires the element
to be in `A` already.
 -/
theorem mem_nonunits_iff_exists_mem_maximalIdeal {a : K} :
    a ∈ A.nonunits ↔ ∃ ha, (⟨a, ha⟩ : A) ∈ LocalRing.maximalIdeal A 
goal: a ∈ A.nonunits ↔ ∃ (ha : a ∈ A), ⟨a, ha⟩ ∈ LocalRing.maximalIdeal ↥A

full_name: ValuationSubring.image_maximalIdeal
code: /-- `A.nonunits` agrees with the maximal ideal of `A`, after taking its image in `K`. -/
theorem image_maximalIdeal : ((↑) : A → K) '' LocalRing.maximalIdeal A = A.nonunits 
goal: Subtype.val '' ↑(LocalRing.maximalIdeal ↥A) = ↑A.nonunits

full_name: ValuationSubring.principalUnitGroup
code: /-- The principal unit group of a valuation subring, as a subgroup of `Kˣ`. -/
def principalUnitGroup : Subgroup Kˣ 
goal: Subgroup Kˣ

full_name: ValuationSubring.principal_units_le_units
code: theorem principal_units_le_units : A.principalUnitGroup ≤ A.unitGroup 
goal: A.principalUnitGroup ≤ A.unitGroup

full_name: ValuationSubring.mem_principalUnitGroup_iff
code: theorem mem_principalUnitGroup_iff (x : Kˣ) :
    x ∈ A.principalUnitGroup ↔ A.valuation ((x : K) - 1) < 1 
goal: x ∈ A.principalUnitGroup ↔ A.valuation (↑x - 1) < 1

full_name: ValuationSubring.principalUnitGroup_le_principalUnitGroup
code: theorem principalUnitGroup_le_principalUnitGroup {A B : ValuationSubring K} :
    B.principalUnitGroup ≤ A.principalUnitGroup ↔ A ≤ B 
goal: B.principalUnitGroup ≤ A.principalUnitGroup ↔ A ≤ B

full_name: ValuationSubring.principalUnitGroup_injective
code: theorem principalUnitGroup_injective :
    Function.Injective (principalUnitGroup : ValuationSubring K → Subgroup _) 
goal: Function.Injective ValuationSubring.principalUnitGroup

full_name: ValuationSubring.eq_iff_principalUnitGroup
code: theorem eq_iff_principalUnitGroup {A B : ValuationSubring K} :
    A = B ↔ A.principalUnitGroup = B.principalUnitGroup 
goal: A = B ↔ A.principalUnitGroup = B.principalUnitGroup

full_name: ValuationSubring.principalUnitGroupOrderEmbedding
code: /-- The map on valuation subrings to their principal unit groups is an order embedding. -/
def principalUnitGroupOrderEmbedding : ValuationSubring K ↪o (Subgroup Kˣ)ᵒᵈ 
goal: ValuationSubring K ↪o (Subgroup Kˣ)ᵒᵈ

full_name: ValuationSubring.coe_mem_principalUnitGroup_iff
code: theorem coe_mem_principalUnitGroup_iff {x : A.unitGroup} :
    (x : Kˣ) ∈ A.principalUnitGroup ↔
      A.unitGroupMulEquiv x ∈ (Units.map (LocalRing.residue A).toMonoidHom).ker 
goal: ↑x ∈ A.principalUnitGroup ↔ A.unitGroupMulEquiv x ∈ (Units.map ↑(LocalRing.residue ↥A)).ker

full_name: ValuationSubring.principalUnitGroupEquiv
code: /-- The principal unit group agrees with the kernel of the canonical map from
the units of `A` to the units of the residue field of `A`. -/
def principalUnitGroupEquiv :
    A.principalUnitGroup ≃* (Units.map (LocalRing.residue A).toMonoidHom).ker 
goal: ↥A.principalUnitGroup ≃* ↥(Units.map ↑(LocalRing.residue ↥A)).ker

full_name: ValuationSubring.principalUnitGroupEquiv_apply
code: theorem principalUnitGroupEquiv_apply (a : A.principalUnitGroup) :
    (((principalUnitGroupEquiv A a : Aˣ) : A) : K) = (a : Kˣ) 
goal: ↑↑↑(A.principalUnitGroupEquiv a) = ↑↑a

full_name: ValuationSubring.principalUnitGroup_symm_apply
code: theorem principalUnitGroup_symm_apply (a : (Units.map (LocalRing.residue A).toMonoidHom).ker) :
    ((A.principalUnitGroupEquiv.symm a : Kˣ) : K) = ((a : Aˣ) : A) 
goal: ↑↑(A.principalUnitGroupEquiv.symm a) = ↑↑↑a

full_name: ValuationSubring.unitGroupToResidueFieldUnits
code: /-- The canonical map from the unit group of `A` to the units of the residue field of `A`. -/
def unitGroupToResidueFieldUnits : A.unitGroup →* (LocalRing.ResidueField A)ˣ 
goal: ↥A.unitGroup →* (LocalRing.ResidueField ↥A)ˣ

full_name: ValuationSubring.coe_unitGroupToResidueFieldUnits_apply
code: @[simp]
theorem coe_unitGroupToResidueFieldUnits_apply (x : A.unitGroup) :
    (A.unitGroupToResidueFieldUnits x : LocalRing.ResidueField A) =
      Ideal.Quotient.mk _ (A.unitGroupMulEquiv x : A) 
goal: ↑(A.unitGroupToResidueFieldUnits x) = (Ideal.Quotient.mk (LocalRing.maximalIdeal ↥A)) ↑(A.unitGroupMulEquiv x)

full_name: ValuationSubring.ker_unitGroupToResidueFieldUnits
code: theorem ker_unitGroupToResidueFieldUnits :
    A.unitGroupToResidueFieldUnits.ker = A.principalUnitGroup.comap A.unitGroup.subtype 
goal: A.unitGroupToResidueFieldUnits.ker = Subgroup.comap A.unitGroup.subtype A.principalUnitGroup

full_name: ValuationSubring.surjective_unitGroupToResidueFieldUnits
code: theorem surjective_unitGroupToResidueFieldUnits :
    Function.Surjective A.unitGroupToResidueFieldUnits 
goal: Function.Surjective ⇑A.unitGroupToResidueFieldUnits

full_name: ValuationSubring.unitsModPrincipalUnitsEquivResidueFieldUnits
code: /-- The quotient of the unit group of `A` by the principal unit group of `A` agrees with
the units of the residue field of `A`. -/
def unitsModPrincipalUnitsEquivResidueFieldUnits :
    A.unitGroup ⧸ A.principalUnitGroup.comap A.unitGroup.subtype ≃* (LocalRing.ResidueField A)ˣ 
goal: ↥A.unitGroup ⧸ Subgroup.comap A.unitGroup.subtype A.principalUnitGroup ≃* (LocalRing.ResidueField ↥A)ˣ

full_name: ValuationSubring.instMulOneClassQuotientSubtypeUnitsMemSubgroupUnitGroupComapSubtypePrincipalUnitGroup
code: /-- Porting note: Lean needs to be reminded of this instance -/
local instance : MulOneClass ({ x // x ∈ unitGroup A } ⧸
  Subgroup.comap (Subgroup.subtype (unitGroup A)) (principalUnitGroup A)) 
goal: MulOneClass (↥A.unitGroup ⧸ Subgroup.comap A.unitGroup.subtype A.principalUnitGroup)

full_name: ValuationSubring.unitsModPrincipalUnitsEquivResidueFieldUnits_comp_quotientGroup_mk
code: theorem unitsModPrincipalUnitsEquivResidueFieldUnits_comp_quotientGroup_mk :
    A.unitsModPrincipalUnitsEquivResidueFieldUnits.toMonoidHom.comp (QuotientGroup.mk' _) =
      A.unitGroupToResidueFieldUnits 
goal: A.unitsModPrincipalUnitsEquivResidueFieldUnits.toMonoidHom.comp
    (QuotientGroup.mk' (Subgroup.comap A.unitGroup.subtype A.principalUnitGroup)) =
  A.unitGroupToResidueFieldUnits

full_name: ValuationSubring.unitsModPrincipalUnitsEquivResidueFieldUnits_comp_quotientGroup_mk_apply
code: theorem unitsModPrincipalUnitsEquivResidueFieldUnits_comp_quotientGroup_mk_apply
    (x : A.unitGroup) :
    A.unitsModPrincipalUnitsEquivResidueFieldUnits.toMonoidHom (QuotientGroup.mk x) =
      A.unitGroupToResidueFieldUnits x 
goal: A.unitsModPrincipalUnitsEquivResidueFieldUnits.toMonoidHom ↑x = A.unitGroupToResidueFieldUnits x

full_name: ValuationSubring.pointwiseHasSMul
code: /-- The action on a valuation subring corresponding to applying the action to every element.

This is available as an instance in the `Pointwise` locale. -/
def pointwiseHasSMul : SMul G (ValuationSubring K) 
goal: SMul G (ValuationSubring K)

full_name: ValuationSubring.coe_pointwise_smul
code: @[simp]
theorem coe_pointwise_smul (g : G) (S : ValuationSubring K) : ↑(g • S) = g • (S : Set K) 
goal: ↑(g • S) = g • ↑S

full_name: ValuationSubring.pointwise_smul_toSubring
code: @[simp]
theorem pointwise_smul_toSubring (g : G) (S : ValuationSubring K) :
    (g • S).toSubring = g • S.toSubring 
goal: (g • S).toSubring = g • S.toSubring

full_name: ValuationSubring.pointwiseMulAction
code: /-- The action on a valuation subring corresponding to applying the action to every element.

This is available as an instance in the `Pointwise` locale.

This is a stronger version of `ValuationSubring.pointwiseSMul`. -/
def pointwiseMulAction : MulAction G (ValuationSubring K) 
goal: MulAction G (ValuationSubring K)

full_name: ValuationSubring.smul_mem_pointwise_smul
code: theorem smul_mem_pointwise_smul (g : G) (x : K) (S : ValuationSubring K) : x ∈ S → g • x ∈ g • S 
goal: x ∈ S → g • x ∈ g • S

full_name: ValuationSubring.instCovariantClassHSMulLe
code: instance : CovariantClass G (ValuationSubring K) HSMul.hSMul LE.le 
goal: CovariantClass G (ValuationSubring K) HSMul.hSMul LE.le

full_name: ValuationSubring.mem_smul_pointwise_iff_exists
code: theorem mem_smul_pointwise_iff_exists (g : G) (x : K) (S : ValuationSubring K) :
    x ∈ g • S ↔ ∃ s : K, s ∈ S ∧ g • s = x 
goal: x ∈ g • S ↔ ∃ s ∈ S, g • s = x

full_name: ValuationSubring.pointwise_central_scalar
code: instance pointwise_central_scalar [MulSemiringAction Gᵐᵒᵖ K] [IsCentralScalar G K] :
    IsCentralScalar G (ValuationSubring K) 
goal: IsCentralScalar G (ValuationSubring K)

full_name: ValuationSubring.smul_mem_pointwise_smul_iff
code: @[simp]
theorem smul_mem_pointwise_smul_iff {g : G} {S : ValuationSubring K} {x : K} :
    g • x ∈ g • S ↔ x ∈ S 
goal: g • x ∈ g • S ↔ x ∈ S

full_name: ValuationSubring.mem_pointwise_smul_iff_inv_smul_mem
code: theorem mem_pointwise_smul_iff_inv_smul_mem {g : G} {S : ValuationSubring K} {x : K} :
    x ∈ g • S ↔ g⁻¹ • x ∈ S 
goal: x ∈ g • S ↔ g⁻¹ • x ∈ S

full_name: ValuationSubring.mem_inv_pointwise_smul_iff
code: theorem mem_inv_pointwise_smul_iff {g : G} {S : ValuationSubring K} {x : K} :
    x ∈ g⁻¹ • S ↔ g • x ∈ S 
goal: x ∈ g⁻¹ • S ↔ g • x ∈ S

full_name: ValuationSubring.pointwise_smul_le_pointwise_smul_iff
code: @[simp]
theorem pointwise_smul_le_pointwise_smul_iff {g : G} {S T : ValuationSubring K} :
    g • S ≤ g • T ↔ S ≤ T 
goal: g • S ≤ g • T ↔ S ≤ T

full_name: ValuationSubring.pointwise_smul_subset_iff
code: theorem pointwise_smul_subset_iff {g : G} {S T : ValuationSubring K} : g • S ≤ T ↔ S ≤ g⁻¹ • T 
goal: g • S ≤ T ↔ S ≤ g⁻¹ • T

full_name: ValuationSubring.subset_pointwise_smul_iff
code: theorem subset_pointwise_smul_iff {g : G} {S T : ValuationSubring K} : S ≤ g • T ↔ g⁻¹ • S ≤ T 
goal: S ≤ g • T ↔ g⁻¹ • S ≤ T

full_name: ValuationSubring.comap
code: /-- The pullback of a valuation subring `A` along a ring homomorphism `K →+* L`. -/
def comap (A : ValuationSubring L) (f : K →+* L) : ValuationSubring K 
goal: ValuationSubring K

full_name: ValuationSubring.coe_comap
code: @[simp]
theorem coe_comap (A : ValuationSubring L) (f : K →+* L) : (A.comap f : Set K) = f ⁻¹' A 
goal: ↑(A.comap f) = ⇑f ⁻¹' ↑A

full_name: ValuationSubring.mem_comap
code: @[simp]
theorem mem_comap {A : ValuationSubring L} {f : K →+* L} {x : K} : x ∈ A.comap f ↔ f x ∈ A 
goal: x ∈ A.comap f ↔ f x ∈ A

full_name: ValuationSubring.comap_comap
code: theorem comap_comap (A : ValuationSubring J) (g : L →+* J) (f : K →+* L) :
    (A.comap g).comap f = A.comap (g.comp f) 
goal: (A.comap g).comap f = A.comap (g.comp f)

full_name: Valuation.mem_unitGroup_iff
code: theorem mem_unitGroup_iff : x ∈ v.valuationSubring.unitGroup ↔ v x = 1 
goal: x ∈ v.valuationSubring.unitGroup ↔ v ↑x = 1