File: Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean

full_name: _aux_Mathlib_RingTheory_GradedAlgebra_HomogeneousLocalization___macroRules_termAt__1
code: local notation "at " x => Localization x
goal: Lean.Macro

full_name: _aux_Mathlib_RingTheory_GradedAlgebra_HomogeneousLocalization___unexpand_Localization_1
code: local notation "at " x => Localization x
goal: Lean.PrettyPrinter.Unexpander

full_name: HomogeneousLocalization.NumDenSameDeg.num
code: /-- Let `x` be a submonoid of `A`, then `NumDenSameDeg 𝒜 x` is a structure with a numerator and a
denominator with same grading such that the denominator is contained in `x`.
-/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure NumDenSameDeg where
  deg : ι
  (num den : 𝒜 deg)
  den_mem : (den : A) ∈ x
goal: ↥(𝒜 self.deg)

full_name: HomogeneousLocalization.NumDenSameDeg.deg
code: /-- Let `x` be a submonoid of `A`, then `NumDenSameDeg 𝒜 x` is a structure with a numerator and a
denominator with same grading such that the denominator is contained in `x`.
-/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure NumDenSameDeg where
  deg : ι
  (num den : 𝒜 deg)
  den_mem : (den : A) ∈ x
goal: ι

full_name: HomogeneousLocalization.NumDenSameDeg.den
code: /-- Let `x` be a submonoid of `A`, then `NumDenSameDeg 𝒜 x` is a structure with a numerator and a
denominator with same grading such that the denominator is contained in `x`.
-/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure NumDenSameDeg where
  deg : ι
  (num den : 𝒜 deg)
  den_mem : (den : A) ∈ x
goal: ↥(𝒜 self.deg)

full_name: HomogeneousLocalization.NumDenSameDeg
code: /-- Let `x` be a submonoid of `A`, then `NumDenSameDeg 𝒜 x` is a structure with a numerator and a
denominator with same grading such that the denominator is contained in `x`.
-/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure NumDenSameDeg where
  deg : ι
  (num den : 𝒜 deg)
  den_mem : (den : A) ∈ x
goal: Type (max u_1 u_3)

full_name: HomogeneousLocalization.NumDenSameDeg.den_mem
code: /-- Let `x` be a submonoid of `A`, then `NumDenSameDeg 𝒜 x` is a structure with a numerator and a
denominator with same grading such that the denominator is contained in `x`.
-/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure NumDenSameDeg where
  deg : ι
  (num den : 𝒜 deg)
  den_mem : (den : A) ∈ x
goal: ↑self.den ∈ x

full_name: HomogeneousLocalization.NumDenSameDeg.ext
code: @[ext]
theorem ext {c1 c2 : NumDenSameDeg 𝒜 x} (hdeg : c1.deg = c2.deg) (hnum : (c1.num : A) = c2.num)
    (hden : (c1.den : A) = c2.den) : c1 = c2 
goal: c1 = c2

full_name: HomogeneousLocalization.NumDenSameDeg.instOne
code: instance : One (NumDenSameDeg 𝒜 x) 
goal: One (HomogeneousLocalization.NumDenSameDeg 𝒜 x)

full_name: HomogeneousLocalization.NumDenSameDeg.deg_one
code: @[simp]
theorem deg_one : (1 : NumDenSameDeg 𝒜 x).deg = 0 
goal: HomogeneousLocalization.NumDenSameDeg.deg 1 = 0

full_name: HomogeneousLocalization.NumDenSameDeg.num_one
code: @[simp]
theorem num_one : ((1 : NumDenSameDeg 𝒜 x).num : A) = 1 
goal: ↑(HomogeneousLocalization.NumDenSameDeg.num 1) = 1

full_name: HomogeneousLocalization.NumDenSameDeg.den_one
code: @[simp]
theorem den_one : ((1 : NumDenSameDeg 𝒜 x).den : A) = 1 
goal: ↑(HomogeneousLocalization.NumDenSameDeg.den 1) = 1

full_name: HomogeneousLocalization.NumDenSameDeg.instZero
code: instance : Zero (NumDenSameDeg 𝒜 x) 
goal: Zero (HomogeneousLocalization.NumDenSameDeg 𝒜 x)

full_name: HomogeneousLocalization.NumDenSameDeg.deg_zero
code: @[simp]
theorem deg_zero : (0 : NumDenSameDeg 𝒜 x).deg = 0 
goal: HomogeneousLocalization.NumDenSameDeg.deg 0 = 0

full_name: HomogeneousLocalization.NumDenSameDeg.num_zero
code: @[simp]
theorem num_zero : (0 : NumDenSameDeg 𝒜 x).num = 0 
goal: HomogeneousLocalization.NumDenSameDeg.num 0 = 0

full_name: HomogeneousLocalization.NumDenSameDeg.den_zero
code: @[simp]
theorem den_zero : ((0 : NumDenSameDeg 𝒜 x).den : A) = 1 
goal: ↑(HomogeneousLocalization.NumDenSameDeg.den 0) = 1

full_name: HomogeneousLocalization.NumDenSameDeg.instMul
code: instance : Mul (NumDenSameDeg 𝒜 x) 
goal: Mul (HomogeneousLocalization.NumDenSameDeg 𝒜 x)

full_name: HomogeneousLocalization.NumDenSameDeg.deg_mul
code: @[simp]
theorem deg_mul (c1 c2 : NumDenSameDeg 𝒜 x) : (c1 * c2).deg = c1.deg + c2.deg 
goal: (c1 * c2).deg = c1.deg + c2.deg

full_name: HomogeneousLocalization.NumDenSameDeg.num_mul
code: @[simp]
theorem num_mul (c1 c2 : NumDenSameDeg 𝒜 x) : ((c1 * c2).num : A) = c1.num * c2.num 
goal: ↑(c1 * c2).num = ↑c1.num * ↑c2.num

full_name: HomogeneousLocalization.NumDenSameDeg.den_mul
code: @[simp]
theorem den_mul (c1 c2 : NumDenSameDeg 𝒜 x) : ((c1 * c2).den : A) = c1.den * c2.den 
goal: ↑(c1 * c2).den = ↑c1.den * ↑c2.den

full_name: HomogeneousLocalization.NumDenSameDeg.instAdd
code: instance : Add (NumDenSameDeg 𝒜 x) 
goal: Add (HomogeneousLocalization.NumDenSameDeg 𝒜 x)

full_name: HomogeneousLocalization.NumDenSameDeg.deg_add
code: @[simp]
theorem deg_add (c1 c2 : NumDenSameDeg 𝒜 x) : (c1 + c2).deg = c1.deg + c2.deg 
goal: (c1 + c2).deg = c1.deg + c2.deg

full_name: HomogeneousLocalization.NumDenSameDeg.num_add
code: @[simp]
theorem num_add (c1 c2 : NumDenSameDeg 𝒜 x) :
    ((c1 + c2).num : A) = c1.den * c2.num + c2.den * c1.num 
goal: ↑(c1 + c2).num = ↑c1.den * ↑c2.num + ↑c2.den * ↑c1.num

full_name: HomogeneousLocalization.NumDenSameDeg.den_add
code: @[simp]
theorem den_add (c1 c2 : NumDenSameDeg 𝒜 x) : ((c1 + c2).den : A) = c1.den * c2.den 
goal: ↑(c1 + c2).den = ↑c1.den * ↑c2.den

full_name: HomogeneousLocalization.NumDenSameDeg.instNeg
code: instance : Neg (NumDenSameDeg 𝒜 x) 
goal: Neg (HomogeneousLocalization.NumDenSameDeg 𝒜 x)

full_name: HomogeneousLocalization.NumDenSameDeg.deg_neg
code: @[simp]
theorem deg_neg (c : NumDenSameDeg 𝒜 x) : (-c).deg = c.deg 
goal: (-c).deg = c.deg

full_name: HomogeneousLocalization.NumDenSameDeg.num_neg
code: @[simp]
theorem num_neg (c : NumDenSameDeg 𝒜 x) : ((-c).num : A) = -c.num 
goal: ↑(-c).num = -↑c.num

full_name: HomogeneousLocalization.NumDenSameDeg.den_neg
code: @[simp]
theorem den_neg (c : NumDenSameDeg 𝒜 x) : ((-c).den : A) = c.den 
goal: ↑(-c).den = ↑c.den

full_name: HomogeneousLocalization.NumDenSameDeg.instCommMonoid
code: instance : CommMonoid (NumDenSameDeg 𝒜 x) 
goal: CommMonoid (HomogeneousLocalization.NumDenSameDeg 𝒜 x)

full_name: HomogeneousLocalization.NumDenSameDeg.instPowNat
code: instance : Pow (NumDenSameDeg 𝒜 x) ℕ 
goal: Pow (HomogeneousLocalization.NumDenSameDeg 𝒜 x) ℕ

full_name: HomogeneousLocalization.NumDenSameDeg.deg_pow
code: @[simp]
theorem deg_pow (c : NumDenSameDeg 𝒜 x) (n : ℕ) : (c ^ n).deg = n • c.deg 
goal: (c ^ n).deg = n • c.deg

full_name: HomogeneousLocalization.NumDenSameDeg.num_pow
code: @[simp]
theorem num_pow (c : NumDenSameDeg 𝒜 x) (n : ℕ) : ((c ^ n).num : A) = (c.num : A) ^ n 
goal: ↑(c ^ n).num = ↑c.num ^ n

full_name: HomogeneousLocalization.NumDenSameDeg.den_pow
code: @[simp]
theorem den_pow (c : NumDenSameDeg 𝒜 x) (n : ℕ) : ((c ^ n).den : A) = (c.den : A) ^ n 
goal: ↑(c ^ n).den = ↑c.den ^ n

full_name: HomogeneousLocalization.NumDenSameDeg.instSMul
code: instance : SMul α (NumDenSameDeg 𝒜 x) 
goal: SMul α (HomogeneousLocalization.NumDenSameDeg 𝒜 x)

full_name: HomogeneousLocalization.NumDenSameDeg.deg_smul
code: @[simp]
theorem deg_smul (c : NumDenSameDeg 𝒜 x) (m : α) : (m • c).deg = c.deg 
goal: (m • c).deg = c.deg

full_name: HomogeneousLocalization.NumDenSameDeg.num_smul
code: @[simp]
theorem num_smul (c : NumDenSameDeg 𝒜 x) (m : α) : ((m • c).num : A) = m • c.num 
goal: ↑(m • c).num = m • ↑c.num

full_name: HomogeneousLocalization.NumDenSameDeg.den_smul
code: @[simp]
theorem den_smul (c : NumDenSameDeg 𝒜 x) (m : α) : ((m • c).den : A) = c.den 
goal: ↑(m • c).den = ↑c.den

full_name: HomogeneousLocalization.NumDenSameDeg.embedding
code: /-- For `x : prime ideal of A` and any `p : NumDenSameDeg 𝒜 x`, or equivalent a numerator and a
denominator of the same degree, we get an element `p.num / p.den` of `Aₓ`.
-/
def embedding (p : NumDenSameDeg 𝒜 x) : at x 
goal: at x

full_name: HomogeneousLocalization
code: /-- For `x : prime ideal of A`, `HomogeneousLocalization 𝒜 x` is `NumDenSameDeg 𝒜 x` modulo the
kernel of `embedding 𝒜 x`. This is essentially the subring of `Aₓ` where the numerator and
denominator share the same grading.
-/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
def HomogeneousLocalization : Type _ 
goal: Type (max u_1 u_3)

full_name: HomogeneousLocalization.mk
code: /-- Construct an element of `HomogeneousLocalization 𝒜 x` from a homogeneous fraction. -/
abbrev mk (y : HomogeneousLocalization.NumDenSameDeg 𝒜 x) : HomogeneousLocalization 𝒜 x 
goal: HomogeneousLocalization 𝒜 x

full_name: HomogeneousLocalization.mk_surjective
code: lemma mk_surjective : Function.Surjective (mk (𝒜 := 𝒜) (x := x)) 
goal: Function.Surjective HomogeneousLocalization.mk

full_name: HomogeneousLocalization.val
code: /-- View an element of `HomogeneousLocalization 𝒜 x` as an element of `Aₓ` by forgetting that the
numerator and denominator are of the same grading.
-/
def val (y : HomogeneousLocalization 𝒜 x) : at x 
goal: at x

full_name: HomogeneousLocalization.val_mk
code: @[simp]
theorem val_mk (i : NumDenSameDeg 𝒜 x) :
    val (mk i) = Localization.mk (i.num : A) ⟨i.den, i.den_mem⟩ 
goal: (HomogeneousLocalization.mk i).val = Localization.mk ↑i.num ⟨↑i.den, ⋯⟩

full_name: HomogeneousLocalization.val_injective
code: @[ext]
theorem val_injective : Function.Injective (HomogeneousLocalization.val (𝒜 := 𝒜) (x := x)) 
goal: Function.Injective HomogeneousLocalization.val

full_name: HomogeneousLocalization.subsingleton
code: lemma subsingleton (hx : 0 ∈ x) : Subsingleton (HomogeneousLocalization 𝒜 x) 
goal: Subsingleton (HomogeneousLocalization 𝒜 x)

full_name: HomogeneousLocalization.hasPow
code: instance hasPow : Pow (HomogeneousLocalization 𝒜 x) ℕ 
goal: Pow (HomogeneousLocalization 𝒜 x) ℕ

full_name: HomogeneousLocalization.mk_pow
code: @[simp] lemma mk_pow (i : NumDenSameDeg 𝒜 x) (n : ℕ) : mk (i ^ n) = mk i ^ n 
goal: HomogeneousLocalization.mk (i ^ n) = HomogeneousLocalization.mk i ^ n

full_name: HomogeneousLocalization.instSMul
code: instance : SMul α (HomogeneousLocalization 𝒜 x) 
goal: SMul α (HomogeneousLocalization 𝒜 x)

full_name: HomogeneousLocalization.mk_smul
code: @[simp] lemma mk_smul (i : NumDenSameDeg 𝒜 x) (m : α) : mk (m • i) = m • mk i 
goal: HomogeneousLocalization.mk (m • i) = m • HomogeneousLocalization.mk i

full_name: HomogeneousLocalization.val_smul
code: @[simp]
theorem val_smul (n : α) : ∀ y : HomogeneousLocalization 𝒜 x, (n • y).val = n • y.val 
goal: (n • y).val = n • y.val

full_name: HomogeneousLocalization.val_nsmul
code: theorem val_nsmul (n : ℕ) (y : HomogeneousLocalization 𝒜 x) : (n • y).val = n • y.val 
goal: (n • y).val = n • y.val

full_name: HomogeneousLocalization.val_zsmul
code: theorem val_zsmul (n : ℤ) (y : HomogeneousLocalization 𝒜 x) : (n • y).val = n • y.val 
goal: (n • y).val = n • y.val

full_name: HomogeneousLocalization.instNeg
code: instance : Neg (HomogeneousLocalization 𝒜 x) 
goal: Neg (HomogeneousLocalization 𝒜 x)

full_name: HomogeneousLocalization.mk_neg
code: @[simp] lemma mk_neg (i : NumDenSameDeg 𝒜 x) : mk (-i) = -mk i 
goal: HomogeneousLocalization.mk (-i) = -HomogeneousLocalization.mk i

full_name: HomogeneousLocalization.instAdd
code: instance : Add (HomogeneousLocalization 𝒜 x) 
goal: Add (HomogeneousLocalization 𝒜 x)

full_name: HomogeneousLocalization.mk_add
code: @[simp] lemma mk_add (i j : NumDenSameDeg 𝒜 x) : mk (i + j) = mk i + mk j 
goal: HomogeneousLocalization.mk (i + j) = HomogeneousLocalization.mk i + HomogeneousLocalization.mk j

full_name: HomogeneousLocalization.instSub
code: instance : Sub (HomogeneousLocalization 𝒜 x) 
goal: Sub (HomogeneousLocalization 𝒜 x)

full_name: HomogeneousLocalization.instMul
code: instance : Mul (HomogeneousLocalization 𝒜 x) 
goal: Mul (HomogeneousLocalization 𝒜 x)

full_name: HomogeneousLocalization.mk_mul
code: @[simp] lemma mk_mul (i j : NumDenSameDeg 𝒜 x) : mk (i * j) = mk i * mk j 
goal: HomogeneousLocalization.mk (i * j) = HomogeneousLocalization.mk i * HomogeneousLocalization.mk j

full_name: HomogeneousLocalization.instOne
code: instance : One (HomogeneousLocalization 𝒜 x) 
goal: One (HomogeneousLocalization 𝒜 x)

full_name: HomogeneousLocalization.mk_one
code: @[simp] lemma mk_one : mk (1 : NumDenSameDeg 𝒜 x) = 1 
goal: HomogeneousLocalization.mk 1 = 1

full_name: HomogeneousLocalization.instZero
code: instance : Zero (HomogeneousLocalization 𝒜 x) 
goal: Zero (HomogeneousLocalization 𝒜 x)

full_name: HomogeneousLocalization.mk_zero
code: @[simp] lemma mk_zero : mk (0 : NumDenSameDeg 𝒜 x) = 0 
goal: HomogeneousLocalization.mk 0 = 0

full_name: HomogeneousLocalization.zero_eq
code: theorem zero_eq : (0 : HomogeneousLocalization 𝒜 x) = Quotient.mk'' 0 
goal: 0 = Quotient.mk'' 0

full_name: HomogeneousLocalization.one_eq
code: theorem one_eq : (1 : HomogeneousLocalization 𝒜 x) = Quotient.mk'' 1 
goal: 1 = Quotient.mk'' 1

full_name: HomogeneousLocalization.val_zero
code: @[simp]
theorem val_zero : (0 : HomogeneousLocalization 𝒜 x).val = 0 
goal: HomogeneousLocalization.val 0 = 0

full_name: HomogeneousLocalization.val_one
code: @[simp]
theorem val_one : (1 : HomogeneousLocalization 𝒜 x).val = 1 
goal: HomogeneousLocalization.val 1 = 1

full_name: HomogeneousLocalization.val_add
code: @[simp]
theorem val_add : ∀ y1 y2 : HomogeneousLocalization 𝒜 x, (y1 + y2).val = y1.val + y2.val 
goal: (y1 + y2).val = y1.val + y2.val

full_name: HomogeneousLocalization.val_mul
code: @[simp]
theorem val_mul : ∀ y1 y2 : HomogeneousLocalization 𝒜 x, (y1 * y2).val = y1.val * y2.val 
goal: (y1 * y2).val = y1.val * y2.val

full_name: HomogeneousLocalization.val_neg
code: @[simp]
theorem val_neg : ∀ y : HomogeneousLocalization 𝒜 x, (-y).val = -y.val 
goal: (-y).val = -y.val

full_name: HomogeneousLocalization.val_sub
code: @[simp]
theorem val_sub (y1 y2 : HomogeneousLocalization 𝒜 x) : (y1 - y2).val = y1.val - y2.val 
goal: (y1 - y2).val = y1.val - y2.val

full_name: HomogeneousLocalization.val_pow
code: @[simp]
theorem val_pow : ∀ (y : HomogeneousLocalization 𝒜 x) (n : ℕ), (y ^ n).val = y.val ^ n 
goal: (y ^ n).val = y.val ^ n

full_name: HomogeneousLocalization.instNatCast
code: instance : NatCast (HomogeneousLocalization 𝒜 x) 
goal: NatCast (HomogeneousLocalization 𝒜 x)

full_name: HomogeneousLocalization.instIntCast
code: instance : IntCast (HomogeneousLocalization 𝒜 x) 
goal: IntCast (HomogeneousLocalization 𝒜 x)

full_name: HomogeneousLocalization.val_natCast
code: @[simp]
theorem val_natCast (n : ℕ) : (n : HomogeneousLocalization 𝒜 x).val = n 
goal: (↑n).val = ↑n

full_name: HomogeneousLocalization.val_intCast
code: @[simp]
theorem val_intCast (n : ℤ) : (n : HomogeneousLocalization 𝒜 x).val = n 
goal: (↑n).val = ↑n

full_name: HomogeneousLocalization.homogenousLocalizationCommRing
code: instance homogenousLocalizationCommRing : CommRing (HomogeneousLocalization 𝒜 x) 
goal: CommRing (HomogeneousLocalization 𝒜 x)

full_name: HomogeneousLocalization.homogeneousLocalizationAlgebra
code: instance homogeneousLocalizationAlgebra :
    Algebra (HomogeneousLocalization 𝒜 x) (Localization x) 
goal: Algebra (HomogeneousLocalization 𝒜 x) (at x)

full_name: HomogeneousLocalization.algebraMap_apply
code: @[simp] lemma algebraMap_apply (y) :
    algebraMap (HomogeneousLocalization 𝒜 x) (Localization x) y = y.val 
goal: (algebraMap (HomogeneousLocalization 𝒜 x) (at x)) y = y.val

full_name: HomogeneousLocalization.mk_eq_zero_of_num
code: lemma mk_eq_zero_of_num (f : NumDenSameDeg 𝒜 x) (h : f.num = 0) : mk f = 0 
goal: HomogeneousLocalization.mk f = 0

full_name: HomogeneousLocalization.mk_eq_zero_of_den
code: lemma mk_eq_zero_of_den (f : NumDenSameDeg 𝒜 x) (h : f.den = 0) : mk f = 0 
goal: HomogeneousLocalization.mk f = 0

full_name: HomogeneousLocalization.num
code: /-- Numerator of an element in `HomogeneousLocalization x`. -/
def num (f : HomogeneousLocalization 𝒜 x) : A 
goal: A

full_name: HomogeneousLocalization.den
code: /-- Denominator of an element in `HomogeneousLocalization x`. -/
def den (f : HomogeneousLocalization 𝒜 x) : A 
goal: A

full_name: HomogeneousLocalization.deg
code: /-- For an element in `HomogeneousLocalization x`, degree is the natural number `i` such that
  `𝒜 i` contains both numerator and denominator. -/
def deg (f : HomogeneousLocalization 𝒜 x) : ι 
goal: ι

full_name: HomogeneousLocalization.den_mem
code: theorem den_mem (f : HomogeneousLocalization 𝒜 x) : f.den ∈ x 
goal: f.den ∈ x

full_name: HomogeneousLocalization.num_mem_deg
code: theorem num_mem_deg (f : HomogeneousLocalization 𝒜 x) : f.num ∈ 𝒜 f.deg 
goal: f.num ∈ 𝒜 f.deg

full_name: HomogeneousLocalization.den_mem_deg
code: theorem den_mem_deg (f : HomogeneousLocalization 𝒜 x) : f.den ∈ 𝒜 f.deg 
goal: f.den ∈ 𝒜 f.deg

full_name: HomogeneousLocalization.eq_num_div_den
code: theorem eq_num_div_den (f : HomogeneousLocalization 𝒜 x) :
    f.val = Localization.mk f.num ⟨f.den, f.den_mem⟩ 
goal: f.val = Localization.mk f.num ⟨f.den, ⋯⟩

full_name: HomogeneousLocalization.den_smul_val
code: theorem den_smul_val (f : HomogeneousLocalization 𝒜 x) :
    f.den • f.val = algebraMap _ _ f.num 
goal: f.den • f.val = (algebraMap A (at x)) f.num

full_name: HomogeneousLocalization.ext_iff_val
code: theorem ext_iff_val (f g : HomogeneousLocalization 𝒜 x) : f = g ↔ f.val = g.val 
goal: f = g ↔ f.val = g.val

full_name: HomogeneousLocalization.AtPrime
code: /-- Localizing a ring homogeneously at a prime ideal. -/
abbrev AtPrime 
goal: Type (max u_1 u_3)

full_name: HomogeneousLocalization.isUnit_iff_isUnit_val
code: theorem isUnit_iff_isUnit_val (f : HomogeneousLocalization.AtPrime 𝒜 𝔭) :
    IsUnit f.val ↔ IsUnit f 
goal: IsUnit (HomogeneousLocalization.val f) ↔ IsUnit f

full_name: HomogeneousLocalization.instNontrivialAtPrime
code: instance : Nontrivial (HomogeneousLocalization.AtPrime 𝒜 𝔭) 
goal: Nontrivial (HomogeneousLocalization.AtPrime 𝒜 𝔭)

full_name: HomogeneousLocalization.localRing
code: instance localRing : LocalRing (HomogeneousLocalization.AtPrime 𝒜 𝔭) 
goal: LocalRing (HomogeneousLocalization.AtPrime 𝒜 𝔭)

full_name: HomogeneousLocalization.Away
code: /-- Localizing away from powers of `f` homogeneously. -/
abbrev Away 
goal: Type (max u_1 u_3)

full_name: HomogeneousLocalization.Away.eventually_smul_mem
code: theorem Away.eventually_smul_mem {m} (hf : f ∈ 𝒜 m) (z : Away 𝒜 f) :
    ∀ᶠ n in Filter.atTop, f ^ n • z.val ∈ algebraMap _ _ '' (𝒜 (n • m) : Set A) 
goal: ∀ᶠ (n : ℕ) in Filter.atTop,
  f ^ n • HomogeneousLocalization.val z ∈ ⇑(algebraMap A (at Submonoid.powers f)) '' ↑(𝒜 (n • m))

full_name: HomogeneousLocalization.map
code: /--
Let `A, B` be two graded algebras with the same indexing set and `g : A → B` be a graded algebra
homomorphism (i.e. `g(Aₘ) ⊆ Bₘ`). Let `P ≤ A` be a submonoid and `Q ≤ B` be a submonoid such that
`P ≤ g⁻¹ Q`, then `g` induce a map from the homogeneous localizations `A⁰_P` to the homogeneous
localizations `B⁰_Q`.
-/
def map (g : A →+* B)
    (comap_le : P ≤ Q.comap g) (hg : ∀ i, ∀ a ∈ 𝒜 i, g a ∈ ℬ i) :
    HomogeneousLocalization 𝒜 P →+* HomogeneousLocalization ℬ Q 
goal: HomogeneousLocalization 𝒜 P →+* HomogeneousLocalization ℬ Q

full_name: HomogeneousLocalization.mapId
code: /--
Let `A` be a graded algebra and `P ≤ Q` be two submonoids, then the homogeneous localization of `A`
at `P` embedds into the homogeneous localization of `A` at `Q`.
-/
abbrev mapId {P Q : Submonoid A} (h : P ≤ Q) :
    HomogeneousLocalization 𝒜 P →+* HomogeneousLocalization 𝒜 Q 
goal: HomogeneousLocalization 𝒜 P →+* HomogeneousLocalization 𝒜 Q

full_name: HomogeneousLocalization.map_mk
code: lemma map_mk (g : A →+* B)
    (comap_le : P ≤ Q.comap g) (hg : ∀ i, ∀ a ∈ 𝒜 i, g a ∈ ℬ i) (x) :
    map 𝒜 ℬ g comap_le hg (mk x) =
    mk ⟨x.1, ⟨_, hg _ _ x.2.2⟩, ⟨_, hg _ _ x.3.2⟩, comap_le x.4⟩ 
goal: (HomogeneousLocalization.map 𝒜 ℬ g comap_le hg) (HomogeneousLocalization.mk x) =
  HomogeneousLocalization.mk { deg := x.deg, num := ⟨g ↑x.num, ⋯⟩, den := ⟨g ↑x.den, ⋯⟩, den_mem := ⋯ }