Documentation

Mathlib.GroupTheory.MonoidLocalization.Basic

Localizations of commutative monoids #

Localizing a commutative ring at one of its submonoids does not rely on the ring's addition, so we can generalize localizations to commutative monoids.

We characterize the localization of a commutative monoid M at a submonoid S up to isomorphism; that is, a commutative monoid N is the localization of M at S iff we can find a monoid homomorphism f : M →* N satisfying 3 properties:

  1. For all y ∈ S, f y is a unit;
  2. For all z : N, there exists (x, y) : M × S such that z * f y = f x;
  3. For all x, y : M such that f x = f y, there exists c ∈ S such that x * c = y * c. (The converse is a consequence of 1.)

Given such a localization map f : M →* N, we can define the surjection Submonoid.LocalizationMap.mk' sending (x, y) : M × S to f x * (f y)⁻¹, and Submonoid.LocalizationMap.lift, the homomorphism from N induced by a homomorphism from M which maps elements of S to invertible elements of the codomain. Similarly, given commutative monoids P, Q, a submonoid T of P and a localization map for T from P to Q, then a homomorphism g : M →* P such that g(S) ⊆ T induces a homomorphism of localizations, LocalizationMap.map, from N to Q.

We also define the quotient of M × S by the unique congruence relation (equivalence relation preserving a binary operation) r such that for any other congruence relation s on M × S satisfying '∀ y ∈ S, (1, 1) ∼ (y, y) under s', we have that (x₁, y₁) ∼ (x₂, y₂) by s whenever (x₁, y₁) ∼ (x₂, y₂) by r. We show this relation is equivalent to the standard localization relation. This defines the localization as a quotient type, Localization, but the majority of subsequent lemmas in the file are given in terms of localizations up to isomorphism, using maps which satisfy the characteristic predicate.

The Grothendieck group construction corresponds to localizing at the top submonoid, namely making every element invertible.

Implementation notes #

In maths it is natural to reason up to isomorphism, but in Lean we cannot naturally rewrite one structure with an isomorphic one; one way around this is to isolate a predicate characterizing a structure up to isomorphism, and reason about things that satisfy the predicate.

The infimum form of the localization congruence relation is chosen as 'canonical' here, since it shortens some proofs.

To apply a localization map f as a function, we use f.toMap, as coercions don't work well for this structure.

To reason about the localization as a quotient type, use mk_eq_monoidOf_mk' and associated lemmas. These show the quotient map mk : M → S → Localization S equals the surjection LocalizationMap.mk' induced by the map Localization.monoidOf : Submonoid.LocalizationMap S (Localization S) (where of establishes the localization as a quotient type satisfies the characteristic predicate). The lemma mk_eq_monoidOf_mk' hence gives you access to the results in the rest of the file, which are about the LocalizationMap.mk' induced by any localization map.

TODO #

Tags #

localization, monoid localization, quotient monoid, congruence relation, characteristic predicate, commutative monoid, grothendieck group

structure AddSubmonoid.LocalizationMap {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) (N : Type u_2) [AddCommMonoid N] extends AddMonoidHom , ZeroHom , AddHom :
Type (max u_1 u_2)

The type of AddMonoid homomorphisms satisfying the characteristic predicate: if f : M →+ N satisfies this predicate, then N is isomorphic to the localization of M at S.

  • toFun : MN
  • map_zero' : (↑self.toAddMonoidHom).toFun 0 = 0
  • map_add' : ∀ (x y : M), (↑self.toAddMonoidHom).toFun (x + y) = (↑self.toAddMonoidHom).toFun x + (↑self.toAddMonoidHom).toFun y
  • map_add_units' : ∀ (y : S), IsAddUnit ((↑self.toAddMonoidHom).toFun y)
  • surj' : ∀ (z : N), ∃ (x : M × S), z + (↑self.toAddMonoidHom).toFun x.2 = (↑self.toAddMonoidHom).toFun x.1
  • exists_of_eq : ∀ (x y : M), (↑self.toAddMonoidHom).toFun x = (↑self.toAddMonoidHom).toFun y∃ (c : S), c + x = c + y
Instances For
    theorem AddSubmonoid.LocalizationMap.map_add_units' {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (self : S.LocalizationMap N) (y : S) :
    IsAddUnit ((↑self.toAddMonoidHom).toFun y)
    theorem AddSubmonoid.LocalizationMap.surj' {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (self : S.LocalizationMap N) (z : N) :
    ∃ (x : M × S), z + (↑self.toAddMonoidHom).toFun x.2 = (↑self.toAddMonoidHom).toFun x.1
    theorem AddSubmonoid.LocalizationMap.exists_of_eq {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (self : S.LocalizationMap N) (x : M) (y : M) :
    (↑self.toAddMonoidHom).toFun x = (↑self.toAddMonoidHom).toFun y∃ (c : S), c + x = c + y
    structure Submonoid.LocalizationMap {M : Type u_1} [CommMonoid M] (S : Submonoid M) (N : Type u_2) [CommMonoid N] extends MonoidHom , OneHom , MulHom :
    Type (max u_1 u_2)

    The type of monoid homomorphisms satisfying the characteristic predicate: if f : M →* N satisfies this predicate, then N is isomorphic to the localization of M at S.

    • toFun : MN
    • map_one' : (↑self.toMonoidHom).toFun 1 = 1
    • map_mul' : ∀ (x y : M), (↑self.toMonoidHom).toFun (x * y) = (↑self.toMonoidHom).toFun x * (↑self.toMonoidHom).toFun y
    • map_units' : ∀ (y : S), IsUnit ((↑self.toMonoidHom).toFun y)
    • surj' : ∀ (z : N), ∃ (x : M × S), z * (↑self.toMonoidHom).toFun x.2 = (↑self.toMonoidHom).toFun x.1
    • exists_of_eq : ∀ (x y : M), (↑self.toMonoidHom).toFun x = (↑self.toMonoidHom).toFun y∃ (c : S), c * x = c * y
    Instances For
      theorem Submonoid.LocalizationMap.map_units' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (self : S.LocalizationMap N) (y : S) :
      IsUnit ((↑self.toMonoidHom).toFun y)
      theorem Submonoid.LocalizationMap.surj' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (self : S.LocalizationMap N) (z : N) :
      ∃ (x : M × S), z * (↑self.toMonoidHom).toFun x.2 = (↑self.toMonoidHom).toFun x.1
      theorem Submonoid.LocalizationMap.exists_of_eq {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (self : S.LocalizationMap N) (x : M) (y : M) :
      (↑self.toMonoidHom).toFun x = (↑self.toMonoidHom).toFun y∃ (c : S), c * x = c * y
      def Localization.r {M : Type u_1} [CommMonoid M] (S : Submonoid M) :
      Con (M × S)

      The congruence relation on M × S, M a CommMonoid and S a submonoid of M, whose quotient is the localization of M at S, defined as the unique congruence relation on M × S such that for any other congruence relation s on M × S where for all y ∈ S, (1, 1) ∼ (y, y) under s, we have that (x₁, y₁) ∼ (x₂, y₂) by r implies (x₁, y₁) ∼ (x₂, y₂) by s.

      Equations
      Instances For
        def AddLocalization.r {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) :
        AddCon (M × S)

        The congruence relation on M × S, M an AddCommMonoid and S an AddSubmonoid of M, whose quotient is the localization of M at S, defined as the unique congruence relation on M × S such that for any other congruence relation s on M × S where for all y ∈ S, (0, 0) ∼ (y, y) under s, we have that (x₁, y₁) ∼ (x₂, y₂) by r implies (x₁, y₁) ∼ (x₂, y₂) by s.

        Equations
        Instances For
          def Localization.r' {M : Type u_1} [CommMonoid M] (S : Submonoid M) :
          Con (M × S)

          An alternate form of the congruence relation on M × S, M a CommMonoid and S a submonoid of M, whose quotient is the localization of M at S.

          Equations
          • Localization.r' S = { r := fun (a b : M × S) => ∃ (c : S), c * (b.2 * a.1) = c * (a.2 * b.1), iseqv := , mul' := }
          Instances For
            def AddLocalization.r' {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) :
            AddCon (M × S)

            An alternate form of the congruence relation on M × S, M a CommMonoid and S a submonoid of M, whose quotient is the localization of M at S.

            Equations
            • AddLocalization.r' S = { r := fun (a b : M × S) => ∃ (c : S), c + (b.2 + a.1) = c + (a.2 + b.1), iseqv := , add' := }
            Instances For

              The congruence relation used to localize a CommMonoid at a submonoid can be expressed equivalently as an infimum (see Localization.r) or explicitly (see Localization.r').

              The additive congruence relation used to localize an AddCommMonoid at a submonoid can be expressed equivalently as an infimum (see AddLocalization.r) or explicitly (see AddLocalization.r').

              theorem Localization.r_iff_exists {M : Type u_1} [CommMonoid M] {S : Submonoid M} {x : M × S} {y : M × S} :
              (Localization.r S) x y ∃ (c : S), c * (y.2 * x.1) = c * (x.2 * y.1)
              theorem AddLocalization.r_iff_exists {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {x : M × S} {y : M × S} :
              (AddLocalization.r S) x y ∃ (c : S), c + (y.2 + x.1) = c + (x.2 + y.1)
              theorem Localization.r_iff_oreEqv_r {M : Type u_1} [CommMonoid M] {S : Submonoid M} {x : M × S} {y : M × S} :
              theorem AddLocalization.r_iff_oreEqv_r {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {x : M × S} {y : M × S} :
              @[reducible, inline]
              abbrev Localization {M : Type u_1} [CommMonoid M] (S : Submonoid M) :
              Type u_1

              The localization of a CommMonoid at one of its submonoids (as a quotient type).

              Equations
              Instances For
                @[reducible, inline]
                abbrev AddLocalization {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) :
                Type u_1

                The localization of an AddCommMonoid at one of its submonoids (as a quotient type).

                Equations
                Instances For
                  def Localization.mk {M : Type u_1} [CommMonoid M] {S : Submonoid M} (x : M) (y : S) :

                  Given a CommMonoid M and submonoid S, mk sends x : M, y ∈ S to the equivalence class of (x, y) in the localization of M at S.

                  Equations
                  Instances For
                    def AddLocalization.mk {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} (x : M) (y : S) :

                    Given an AddCommMonoid M and submonoid S, mk sends x : M, y ∈ S to the equivalence class of (x, y) in the localization of M at S.

                    Equations
                    Instances For
                      theorem Localization.mk_eq_mk_iff {M : Type u_1} [CommMonoid M] {S : Submonoid M} {a : M} {c : M} {b : S} {d : S} :
                      theorem AddLocalization.mk_eq_mk_iff {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {a : M} {c : M} {b : S} {d : S} :
                      def Localization.rec {M : Type u_1} [CommMonoid M] {S : Submonoid M} {p : Localization SSort u} (f : (a : M) → (b : S) → p (Localization.mk a b)) (H : ∀ {a c : M} {b d : S} (h : (Localization.r S) (a, b) (c, d)), f a b = f c d) (x : Localization S) :
                      p x

                      Dependent recursion principle for Localizations: given elements f a b : p (mk a b) for all a b, such that r S (a, b) (c, d) implies f a b = f c d (with the correct coercions), then f is defined on the whole Localization S.

                      Equations
                      Instances For
                        def AddLocalization.rec {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : AddLocalization SSort u} (f : (a : M) → (b : S) → p (AddLocalization.mk a b)) (H : ∀ {a c : M} {b d : S} (h : (AddLocalization.r S) (a, b) (c, d)), f a b = f c d) (x : AddLocalization S) :
                        p x

                        Dependent recursion principle for AddLocalizations: given elements f a b : p (mk a b) for all a b, such that r S (a, b) (c, d) implies f a b = f c d (with the correct coercions), then f is defined on the whole AddLocalization S.

                        Equations
                        Instances For
                          def Localization.recOnSubsingleton₂ {M : Type u_1} [CommMonoid M] {S : Submonoid M} {r : Localization SLocalization SSort u} [h : ∀ (a c : M) (b d : S), Subsingleton (r (Localization.mk a b) (Localization.mk c d))] (x : Localization S) (y : Localization S) (f : (a c : M) → (b d : S) → r (Localization.mk a b) (Localization.mk c d)) :
                          r x y

                          Copy of Quotient.recOnSubsingleton₂ for Localization

                          Equations
                          • One or more equations did not get rendered due to their size.
                          Instances For
                            def AddLocalization.recOnSubsingleton₂ {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {r : AddLocalization SAddLocalization SSort u} [h : ∀ (a c : M) (b d : S), Subsingleton (r (AddLocalization.mk a b) (AddLocalization.mk c d))] (x : AddLocalization S) (y : AddLocalization S) (f : (a c : M) → (b d : S) → r (AddLocalization.mk a b) (AddLocalization.mk c d)) :
                            r x y

                            Copy of Quotient.recOnSubsingleton₂ for AddLocalization

                            Equations
                            • One or more equations did not get rendered due to their size.
                            Instances For
                              theorem Localization.mk_mul {M : Type u_1} [CommMonoid M] {S : Submonoid M} (a : M) (c : M) (b : S) (d : S) :
                              theorem AddLocalization.mk_add {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} (a : M) (c : M) (b : S) (d : S) :
                              theorem Localization.mk_pow {M : Type u_1} [CommMonoid M] {S : Submonoid M} (n : ) (a : M) (b : S) :
                              Localization.mk a b ^ n = Localization.mk (a ^ n) (b ^ n)
                              theorem AddLocalization.mk_nsmul {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} (n : ) (a : M) (b : S) :
                              @[simp]
                              theorem Localization.ndrec_mk {M : Type u_1} [CommMonoid M] {S : Submonoid M} {p : Localization SSort u} (f : (a : M) → (b : S) → p (Localization.mk a b)) (H : ∀ {a c : M} {b d : S} (h : (Localization.r S) (a, b) (c, d)), f a b = f c d) (a : M) (b : S) :
                              @[simp]
                              theorem AddLocalization.ndrec_mk {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : AddLocalization SSort u} (f : (a : M) → (b : S) → p (AddLocalization.mk a b)) (H : ∀ {a c : M} {b d : S} (h : (AddLocalization.r S) (a, b) (c, d)), f a b = f c d) (a : M) (b : S) :
                              def Localization.liftOn {M : Type u_1} [CommMonoid M] {S : Submonoid M} {p : Sort u} (x : Localization S) (f : MSp) (H : ∀ {a c : M} {b d : S}, (Localization.r S) (a, b) (c, d)f a b = f c d) :
                              p

                              Non-dependent recursion principle for localizations: given elements f a b : p for all a b, such that r S (a, b) (c, d) implies f a b = f c d, then f is defined on the whole Localization S.

                              Equations
                              Instances For
                                def AddLocalization.liftOn {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u} (x : AddLocalization S) (f : MSp) (H : ∀ {a c : M} {b d : S}, (AddLocalization.r S) (a, b) (c, d)f a b = f c d) :
                                p

                                Non-dependent recursion principle for AddLocalizations: given elements f a b : p for all a b, such that r S (a, b) (c, d) implies f a b = f c d, then f is defined on the whole Localization S.

                                Equations
                                Instances For
                                  theorem Localization.liftOn_mk {M : Type u_1} [CommMonoid M] {S : Submonoid M} {p : Sort u} (f : MSp) (H : ∀ {a c : M} {b d : S}, (Localization.r S) (a, b) (c, d)f a b = f c d) (a : M) (b : S) :
                                  (Localization.mk a b).liftOn f H = f a b
                                  theorem AddLocalization.liftOn_mk {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u} (f : MSp) (H : ∀ {a c : M} {b d : S}, (AddLocalization.r S) (a, b) (c, d)f a b = f c d) (a : M) (b : S) :
                                  (AddLocalization.mk a b).liftOn f H = f a b
                                  theorem Localization.ind {M : Type u_1} [CommMonoid M] {S : Submonoid M} {p : Localization SProp} (H : ∀ (y : M × S), p (Localization.mk y.1 y.2)) (x : Localization S) :
                                  p x
                                  theorem AddLocalization.ind {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : AddLocalization SProp} (H : ∀ (y : M × S), p (AddLocalization.mk y.1 y.2)) (x : AddLocalization S) :
                                  p x
                                  theorem Localization.induction_on {M : Type u_1} [CommMonoid M] {S : Submonoid M} {p : Localization SProp} (x : Localization S) (H : ∀ (y : M × S), p (Localization.mk y.1 y.2)) :
                                  p x
                                  theorem AddLocalization.induction_on {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : AddLocalization SProp} (x : AddLocalization S) (H : ∀ (y : M × S), p (AddLocalization.mk y.1 y.2)) :
                                  p x
                                  def Localization.liftOn₂ {M : Type u_1} [CommMonoid M] {S : Submonoid M} {p : Sort u} (x : Localization S) (y : Localization S) (f : MSMSp) (H : ∀ {a a' : M} {b b' : S} {c c' : M} {d d' : S}, (Localization.r S) (a, b) (a', b')(Localization.r S) (c, d) (c', d')f a b c d = f a' b' c' d') :
                                  p

                                  Non-dependent recursion principle for localizations: given elements f x y : p for all x and y, such that r S x x' and r S y y' implies f x y = f x' y', then f is defined on the whole Localization S.

                                  Equations
                                  • x.liftOn₂ y f H = x.liftOn (fun (a : M) (b : S) => y.liftOn (f a b) )
                                  Instances For
                                    def AddLocalization.liftOn₂ {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u} (x : AddLocalization S) (y : AddLocalization S) (f : MSMSp) (H : ∀ {a a' : M} {b b' : S} {c c' : M} {d d' : S}, (AddLocalization.r S) (a, b) (a', b')(AddLocalization.r S) (c, d) (c', d')f a b c d = f a' b' c' d') :
                                    p

                                    Non-dependent recursion principle for localizations: given elements f x y : p for all x and y, such that r S x x' and r S y y' implies f x y = f x' y', then f is defined on the whole Localization S.

                                    Equations
                                    • x.liftOn₂ y f H = x.liftOn (fun (a : M) (b : S) => y.liftOn (f a b) )
                                    Instances For
                                      theorem Localization.liftOn₂_mk {M : Type u_1} [CommMonoid M] {S : Submonoid M} {p : Sort u_4} (f : MSMSp) (H : ∀ {a a' : M} {b b' : S} {c c' : M} {d d' : S}, (Localization.r S) (a, b) (a', b')(Localization.r S) (c, d) (c', d')f a b c d = f a' b' c' d') (a : M) (c : M) (b : S) (d : S) :
                                      (Localization.mk a b).liftOn₂ (Localization.mk c d) f H = f a b c d
                                      theorem AddLocalization.liftOn₂_mk {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u_4} (f : MSMSp) (H : ∀ {a a' : M} {b b' : S} {c c' : M} {d d' : S}, (AddLocalization.r S) (a, b) (a', b')(AddLocalization.r S) (c, d) (c', d')f a b c d = f a' b' c' d') (a : M) (c : M) (b : S) (d : S) :
                                      (AddLocalization.mk a b).liftOn₂ (AddLocalization.mk c d) f H = f a b c d
                                      theorem Localization.induction_on₂ {M : Type u_1} [CommMonoid M] {S : Submonoid M} {p : Localization SLocalization SProp} (x : Localization S) (y : Localization S) (H : ∀ (x y : M × S), p (Localization.mk x.1 x.2) (Localization.mk y.1 y.2)) :
                                      p x y
                                      theorem AddLocalization.induction_on₂ {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : AddLocalization SAddLocalization SProp} (x : AddLocalization S) (y : AddLocalization S) (H : ∀ (x y : M × S), p (AddLocalization.mk x.1 x.2) (AddLocalization.mk y.1 y.2)) :
                                      p x y
                                      theorem Localization.induction_on₃ {M : Type u_1} [CommMonoid M] {S : Submonoid M} {p : Localization SLocalization SLocalization SProp} (x : Localization S) (y : Localization S) (z : Localization S) (H : ∀ (x y z : M × S), p (Localization.mk x.1 x.2) (Localization.mk y.1 y.2) (Localization.mk z.1 z.2)) :
                                      p x y z
                                      theorem AddLocalization.induction_on₃ {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : AddLocalization SAddLocalization SAddLocalization SProp} (x : AddLocalization S) (y : AddLocalization S) (z : AddLocalization S) (H : ∀ (x y z : M × S), p (AddLocalization.mk x.1 x.2) (AddLocalization.mk y.1 y.2) (AddLocalization.mk z.1 z.2)) :
                                      p x y z
                                      theorem Localization.one_rel {M : Type u_1} [CommMonoid M] {S : Submonoid M} (y : S) :
                                      (Localization.r S) 1 (y, y)
                                      theorem AddLocalization.zero_rel {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} (y : S) :
                                      (AddLocalization.r S) 0 (y, y)
                                      theorem Localization.r_of_eq {M : Type u_1} [CommMonoid M] {S : Submonoid M} {x : M × S} {y : M × S} (h : y.2 * x.1 = x.2 * y.1) :
                                      theorem AddLocalization.r_of_eq {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {x : M × S} {y : M × S} (h : y.2 + x.1 = x.2 + y.1) :
                                      theorem Localization.mk_self {M : Type u_1} [CommMonoid M] {S : Submonoid M} (a : S) :
                                      Localization.mk (↑a) a = 1
                                      theorem AddLocalization.mk_self {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} (a : S) :
                                      theorem Localization.smul_mk {M : Type u_1} [CommMonoid M] {S : Submonoid M} {R : Type u_4} [SMul R M] [IsScalarTower R M M] (c : R) (a : M) (b : S) :
                                      Equations
                                      • =
                                      def MonoidHom.toLocalizationMap {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : M →* N) (H1 : ∀ (y : S), IsUnit (f y)) (H2 : ∀ (z : N), ∃ (x : M × S), z * f x.2 = f x.1) (H3 : ∀ (x y : M), f x = f y∃ (c : S), c * x = c * y) :
                                      S.LocalizationMap N

                                      Makes a localization map from a CommMonoid hom satisfying the characteristic predicate.

                                      Equations
                                      • f.toLocalizationMap H1 H2 H3 = { toMonoidHom := f, map_units' := H1, surj' := H2, exists_of_eq := H3 }
                                      Instances For
                                        def AddMonoidHom.toLocalizationMap {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : M →+ N) (H1 : ∀ (y : S), IsAddUnit (f y)) (H2 : ∀ (z : N), ∃ (x : M × S), z + f x.2 = f x.1) (H3 : ∀ (x y : M), f x = f y∃ (c : S), c + x = c + y) :
                                        S.LocalizationMap N

                                        Makes a localization map from an AddCommMonoid hom satisfying the characteristic predicate.

                                        Equations
                                        • f.toLocalizationMap H1 H2 H3 = { toAddMonoidHom := f, map_add_units' := H1, surj' := H2, exists_of_eq := H3 }
                                        Instances For
                                          @[reducible, inline]
                                          abbrev Submonoid.LocalizationMap.toMap {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) :
                                          M →* N

                                          Short for toMonoidHom; used to apply a localization map as a function.

                                          Equations
                                          • f.toMap = f.toMonoidHom
                                          Instances For
                                            @[reducible, inline]
                                            abbrev AddSubmonoid.LocalizationMap.toMap {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) :
                                            M →+ N

                                            Short for toAddMonoidHom; used to apply a localization map as a function.

                                            Equations
                                            • f.toMap = f.toAddMonoidHom
                                            Instances For
                                              theorem AddSubmonoid.LocalizationMap.ext {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : S.LocalizationMap N} {g : S.LocalizationMap N} (h : ∀ (x : M), f.toMap x = g.toMap x) :
                                              f = g
                                              theorem Submonoid.LocalizationMap.ext {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : S.LocalizationMap N} {g : S.LocalizationMap N} (h : ∀ (x : M), f.toMap x = g.toMap x) :
                                              f = g
                                              theorem Submonoid.LocalizationMap.toMap_injective {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] :
                                              Function.Injective Submonoid.LocalizationMap.toMap
                                              theorem AddSubmonoid.LocalizationMap.toMap_injective {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] :
                                              Function.Injective AddSubmonoid.LocalizationMap.toMap
                                              theorem Submonoid.LocalizationMap.map_units {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) (y : S) :
                                              IsUnit (f.toMap y)
                                              theorem AddSubmonoid.LocalizationMap.map_addUnits {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) (y : S) :
                                              IsAddUnit (f.toMap y)
                                              theorem Submonoid.LocalizationMap.surj {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) (z : N) :
                                              ∃ (x : M × S), z * f.toMap x.2 = f.toMap x.1
                                              theorem AddSubmonoid.LocalizationMap.surj {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) (z : N) :
                                              ∃ (x : M × S), z + f.toMap x.2 = f.toMap x.1
                                              theorem Submonoid.LocalizationMap.surj₂ {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) (z : N) (w : N) :
                                              ∃ (z' : M) (w' : M) (d : S), z * f.toMap d = f.toMap z' w * f.toMap d = f.toMap w'

                                              Given a localization map f : M →* N, and z w : N, there exist z' w' : M and d : S such that f z' / f d = z and f w' / f d = w.

                                              theorem AddSubmonoid.LocalizationMap.surj₂ {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) (z : N) (w : N) :
                                              ∃ (z' : M) (w' : M) (d : S), z + f.toMap d = f.toMap z' w + f.toMap d = f.toMap w'

                                              Given a localization map f : M →+ N, and z w : N, there exist z' w' : M and d : S such that f z' - f d = z and f w' - f d = w.

                                              theorem Submonoid.LocalizationMap.eq_iff_exists {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) {x : M} {y : M} :
                                              f.toMap x = f.toMap y ∃ (c : S), c * x = c * y
                                              theorem AddSubmonoid.LocalizationMap.eq_iff_exists {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) {x : M} {y : M} :
                                              f.toMap x = f.toMap y ∃ (c : S), c + x = c + y
                                              noncomputable def Submonoid.LocalizationMap.sec {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) (z : N) :
                                              M × S

                                              Given a localization map f : M →* N, a section function sending z : N to some (x, y) : M × S such that f x * (f y)⁻¹ = z.

                                              Equations
                                              Instances For
                                                noncomputable def AddSubmonoid.LocalizationMap.sec {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) (z : N) :
                                                M × S

                                                Given a localization map f : M →+ N, a section function sending z : N to some (x, y) : M × S such that f x - f y = z.

                                                Equations
                                                Instances For
                                                  theorem Submonoid.LocalizationMap.sec_spec {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : S.LocalizationMap N} (z : N) :
                                                  z * f.toMap (f.sec z).2 = f.toMap (f.sec z).1
                                                  theorem AddSubmonoid.LocalizationMap.sec_spec {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : S.LocalizationMap N} (z : N) :
                                                  z + f.toMap (f.sec z).2 = f.toMap (f.sec z).1
                                                  theorem Submonoid.LocalizationMap.sec_spec' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : S.LocalizationMap N} (z : N) :
                                                  f.toMap (f.sec z).1 = f.toMap (f.sec z).2 * z
                                                  theorem AddSubmonoid.LocalizationMap.sec_spec' {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : S.LocalizationMap N} (z : N) :
                                                  f.toMap (f.sec z).1 = f.toMap (f.sec z).2 + z
                                                  theorem Submonoid.LocalizationMap.mul_inv_left {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : M →* N} (h : ∀ (y : S), IsUnit (f y)) (y : S) (w : N) (z : N) :
                                                  w * ((IsUnit.liftRight (f.restrict S) h) y)⁻¹ = z w = f y * z

                                                  Given a MonoidHom f : M →* N and Submonoid S ⊆ M such that f(S) ⊆ Nˣ, for all w, z : N and y ∈ S, we have w * (f y)⁻¹ = z ↔ w = f y * z.

                                                  theorem AddSubmonoid.LocalizationMap.add_neg_left {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : M →+ N} (h : ∀ (y : S), IsAddUnit (f y)) (y : S) (w : N) (z : N) :
                                                  w + (-(IsAddUnit.liftRight (f.restrict S) h) y) = z w = f y + z

                                                  Given an AddMonoidHom f : M →+ N and Submonoid S ⊆ M such that f(S) ⊆ AddUnits N, for all w, z : N and y ∈ S, we have w - f y = z ↔ w = f y + z.

                                                  theorem Submonoid.LocalizationMap.mul_inv_right {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : M →* N} (h : ∀ (y : S), IsUnit (f y)) (y : S) (w : N) (z : N) :
                                                  z = w * ((IsUnit.liftRight (f.restrict S) h) y)⁻¹ z * f y = w

                                                  Given a MonoidHom f : M →* N and Submonoid S ⊆ M such that f(S) ⊆ Nˣ, for all w, z : N and y ∈ S, we have z = w * (f y)⁻¹ ↔ z * f y = w.

                                                  theorem AddSubmonoid.LocalizationMap.add_neg_right {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : M →+ N} (h : ∀ (y : S), IsAddUnit (f y)) (y : S) (w : N) (z : N) :
                                                  z = w + (-(IsAddUnit.liftRight (f.restrict S) h) y) z + f y = w

                                                  Given an AddMonoidHom f : M →+ N and Submonoid S ⊆ M such that f(S) ⊆ AddUnits N, for all w, z : N and y ∈ S, we have z = w - f y ↔ z + f y = w.

                                                  @[simp]
                                                  theorem Submonoid.LocalizationMap.mul_inv {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : M →* N} (h : ∀ (y : S), IsUnit (f y)) {x₁ : M} {x₂ : M} {y₁ : S} {y₂ : S} :
                                                  f x₁ * ((IsUnit.liftRight (f.restrict S) h) y₁)⁻¹ = f x₂ * ((IsUnit.liftRight (f.restrict S) h) y₂)⁻¹ f (x₁ * y₂) = f (x₂ * y₁)

                                                  Given a MonoidHom f : M →* N and Submonoid S ⊆ M such that f(S) ⊆ Nˣ, for all x₁ x₂ : M and y₁, y₂ ∈ S, we have f x₁ * (f y₁)⁻¹ = f x₂ * (f y₂)⁻¹ ↔ f (x₁ * y₂) = f (x₂ * y₁).

                                                  @[simp]
                                                  theorem AddSubmonoid.LocalizationMap.add_neg {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : M →+ N} (h : ∀ (y : S), IsAddUnit (f y)) {x₁ : M} {x₂ : M} {y₁ : S} {y₂ : S} :
                                                  f x₁ + (-(IsAddUnit.liftRight (f.restrict S) h) y₁) = f x₂ + (-(IsAddUnit.liftRight (f.restrict S) h) y₂) f (x₁ + y₂) = f (x₂ + y₁)

                                                  Given an AddMonoidHom f : M →+ N and Submonoid S ⊆ M such that f(S) ⊆ AddUnits N, for all x₁ x₂ : M and y₁, y₂ ∈ S, we have f x₁ - f y₁ = f x₂ - f y₂ ↔ f (x₁ + y₂) = f (x₂ + y₁).

                                                  theorem Submonoid.LocalizationMap.inv_inj {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : M →* N} (hf : ∀ (y : S), IsUnit (f y)) {y : S} {z : S} (h : ((IsUnit.liftRight (f.restrict S) hf) y)⁻¹ = ((IsUnit.liftRight (f.restrict S) hf) z)⁻¹) :
                                                  f y = f z

                                                  Given a MonoidHom f : M →* N and Submonoid S ⊆ M such that f(S) ⊆ Nˣ, for all y, z ∈ S, we have (f y)⁻¹ = (f z)⁻¹ → f y = f z.

                                                  theorem AddSubmonoid.LocalizationMap.neg_inj {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : M →+ N} (hf : ∀ (y : S), IsAddUnit (f y)) {y : S} {z : S} (h : -(IsAddUnit.liftRight (f.restrict S) hf) y = -(IsAddUnit.liftRight (f.restrict S) hf) z) :
                                                  f y = f z

                                                  Given an AddMonoidHom f : M →+ N and Submonoid S ⊆ M such that f(S) ⊆ AddUnits N, for all y, z ∈ S, we have - (f y) = - (f z) → f y = f z.

                                                  theorem Submonoid.LocalizationMap.inv_unique {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : M →* N} (h : ∀ (y : S), IsUnit (f y)) {y : S} {z : N} (H : f y * z = 1) :
                                                  ((IsUnit.liftRight (f.restrict S) h) y)⁻¹ = z

                                                  Given a MonoidHom f : M →* N and Submonoid S ⊆ M such that f(S) ⊆ Nˣ, for all y ∈ S, (f y)⁻¹ is unique.

                                                  theorem AddSubmonoid.LocalizationMap.neg_unique {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : M →+ N} (h : ∀ (y : S), IsAddUnit (f y)) {y : S} {z : N} (H : f y + z = 0) :
                                                  (-(IsAddUnit.liftRight (f.restrict S) h) y) = z

                                                  Given an AddMonoidHom f : M →+ N and Submonoid S ⊆ M such that f(S) ⊆ AddUnits N, for all y ∈ S, - (f y) is unique.

                                                  theorem Submonoid.LocalizationMap.map_right_cancel {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) {x : M} {y : M} {c : S} (h : f.toMap (c * x) = f.toMap (c * y)) :
                                                  f.toMap x = f.toMap y
                                                  theorem AddSubmonoid.LocalizationMap.map_right_cancel {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) {x : M} {y : M} {c : S} (h : f.toMap (c + x) = f.toMap (c + y)) :
                                                  f.toMap x = f.toMap y
                                                  theorem Submonoid.LocalizationMap.map_left_cancel {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) {x : M} {y : M} {c : S} (h : f.toMap (x * c) = f.toMap (y * c)) :
                                                  f.toMap x = f.toMap y
                                                  theorem AddSubmonoid.LocalizationMap.map_left_cancel {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) {x : M} {y : M} {c : S} (h : f.toMap (x + c) = f.toMap (y + c)) :
                                                  f.toMap x = f.toMap y
                                                  noncomputable def Submonoid.LocalizationMap.mk' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) (x : M) (y : S) :
                                                  N

                                                  Given a localization map f : M →* N, the surjection sending (x, y) : M × S to f x * (f y)⁻¹.

                                                  Equations
                                                  Instances For
                                                    noncomputable def AddSubmonoid.LocalizationMap.mk' {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) (x : M) (y : S) :
                                                    N

                                                    Given a localization map f : M →+ N, the surjection sending (x, y) : M × S to f x - f y.

                                                    Equations
                                                    Instances For
                                                      theorem Submonoid.LocalizationMap.mk'_mul {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) (x₁ : M) (x₂ : M) (y₁ : S) (y₂ : S) :
                                                      f.mk' (x₁ * x₂) (y₁ * y₂) = f.mk' x₁ y₁ * f.mk' x₂ y₂
                                                      theorem AddSubmonoid.LocalizationMap.mk'_add {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) (x₁ : M) (x₂ : M) (y₁ : S) (y₂ : S) :
                                                      f.mk' (x₁ + x₂) (y₁ + y₂) = f.mk' x₁ y₁ + f.mk' x₂ y₂
                                                      theorem Submonoid.LocalizationMap.mk'_one {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) (x : M) :
                                                      f.mk' x 1 = f.toMap x
                                                      theorem AddSubmonoid.LocalizationMap.mk'_zero {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) (x : M) :
                                                      f.mk' x 0 = f.toMap x
                                                      @[simp]
                                                      theorem Submonoid.LocalizationMap.mk'_sec {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) (z : N) :
                                                      f.mk' (f.sec z).1 (f.sec z).2 = z

                                                      Given a localization map f : M →* N for a submonoid S ⊆ M, for all z : N we have that if x : M, y ∈ S are such that z * f y = f x, then f x * (f y)⁻¹ = z.

                                                      @[simp]
                                                      theorem AddSubmonoid.LocalizationMap.mk'_sec {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) (z : N) :
                                                      f.mk' (f.sec z).1 (f.sec z).2 = z

                                                      Given a localization map f : M →+ N for a Submonoid S ⊆ M, for all z : N we have that if x : M, y ∈ S are such that z + f y = f x, then f x - f y = z.

                                                      theorem Submonoid.LocalizationMap.mk'_surjective {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) (z : N) :
                                                      ∃ (x : M) (y : S), f.mk' x y = z
                                                      theorem AddSubmonoid.LocalizationMap.mk'_surjective {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) (z : N) :
                                                      ∃ (x : M) (y : S), f.mk' x y = z
                                                      theorem Submonoid.LocalizationMap.mk'_spec {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) (x : M) (y : S) :
                                                      f.mk' x y * f.toMap y = f.toMap x
                                                      theorem AddSubmonoid.LocalizationMap.mk'_spec {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) (x : M) (y : S) :
                                                      f.mk' x y + f.toMap y = f.toMap x
                                                      theorem Submonoid.LocalizationMap.mk'_spec' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) (x : M) (y : S) :
                                                      f.toMap y * f.mk' x y = f.toMap x
                                                      theorem AddSubmonoid.LocalizationMap.mk'_spec' {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) (x : M) (y : S) :
                                                      f.toMap y + f.mk' x y = f.toMap x
                                                      theorem Submonoid.LocalizationMap.eq_mk'_iff_mul_eq {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) {x : M} {y : S} {z : N} :
                                                      z = f.mk' x y z * f.toMap y = f.toMap x
                                                      theorem AddSubmonoid.LocalizationMap.eq_mk'_iff_add_eq {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) {x : M} {y : S} {z : N} :
                                                      z = f.mk' x y z + f.toMap y = f.toMap x
                                                      theorem Submonoid.LocalizationMap.mk'_eq_iff_eq_mul {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) {x : M} {y : S} {z : N} :
                                                      f.mk' x y = z f.toMap x = z * f.toMap y
                                                      theorem AddSubmonoid.LocalizationMap.mk'_eq_iff_eq_add {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) {x : M} {y : S} {z : N} :
                                                      f.mk' x y = z f.toMap x = z + f.toMap y
                                                      theorem Submonoid.LocalizationMap.mk'_eq_iff_eq {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) {x₁ : M} {x₂ : M} {y₁ : S} {y₂ : S} :
                                                      f.mk' x₁ y₁ = f.mk' x₂ y₂ f.toMap (y₂ * x₁) = f.toMap (y₁ * x₂)
                                                      theorem AddSubmonoid.LocalizationMap.mk'_eq_iff_eq {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) {x₁ : M} {x₂ : M} {y₁ : S} {y₂ : S} :
                                                      f.mk' x₁ y₁ = f.mk' x₂ y₂ f.toMap (y₂ + x₁) = f.toMap (y₁ + x₂)
                                                      theorem Submonoid.LocalizationMap.mk'_eq_iff_eq' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) {x₁ : M} {x₂ : M} {y₁ : S} {y₂ : S} :
                                                      f.mk' x₁ y₁ = f.mk' x₂ y₂ f.toMap (x₁ * y₂) = f.toMap (x₂ * y₁)
                                                      theorem AddSubmonoid.LocalizationMap.mk'_eq_iff_eq' {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) {x₁ : M} {x₂ : M} {y₁ : S} {y₂ : S} :
                                                      f.mk' x₁ y₁ = f.mk' x₂ y₂ f.toMap (x₁ + y₂) = f.toMap (x₂ + y₁)
                                                      theorem Submonoid.LocalizationMap.eq {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) {a₁ : M} {b₁ : M} {a₂ : S} {b₂ : S} :
                                                      f.mk' a₁ a₂ = f.mk' b₁ b₂ ∃ (c : S), c * (b₂ * a₁) = c * (a₂ * b₁)
                                                      theorem AddSubmonoid.LocalizationMap.eq {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) {a₁ : M} {b₁ : M} {a₂ : S} {b₂ : S} :
                                                      f.mk' a₁ a₂ = f.mk' b₁ b₂ ∃ (c : S), c + (b₂ + a₁) = c + (a₂ + b₁)
                                                      theorem Submonoid.LocalizationMap.eq' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) {a₁ : M} {b₁ : M} {a₂ : S} {b₂ : S} :
                                                      f.mk' a₁ a₂ = f.mk' b₁ b₂ (Localization.r S) (a₁, a₂) (b₁, b₂)
                                                      theorem AddSubmonoid.LocalizationMap.eq' {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) {a₁ : M} {b₁ : M} {a₂ : S} {b₂ : S} :
                                                      f.mk' a₁ a₂ = f.mk' b₁ b₂ (AddLocalization.r S) (a₁, a₂) (b₁, b₂)
                                                      theorem Submonoid.LocalizationMap.eq_iff_eq {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) (g : S.LocalizationMap P) {x : M} {y : M} :
                                                      f.toMap x = f.toMap y g.toMap x = g.toMap y
                                                      theorem AddSubmonoid.LocalizationMap.eq_iff_eq {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) (g : S.LocalizationMap P) {x : M} {y : M} :
                                                      f.toMap x = f.toMap y g.toMap x = g.toMap y
                                                      theorem Submonoid.LocalizationMap.mk'_eq_iff_mk'_eq {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) (g : S.LocalizationMap P) {x₁ : M} {x₂ : M} {y₁ : S} {y₂ : S} :
                                                      f.mk' x₁ y₁ = f.mk' x₂ y₂ g.mk' x₁ y₁ = g.mk' x₂ y₂
                                                      theorem AddSubmonoid.LocalizationMap.mk'_eq_iff_mk'_eq {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) (g : S.LocalizationMap P) {x₁ : M} {x₂ : M} {y₁ : S} {y₂ : S} :
                                                      f.mk' x₁ y₁ = f.mk' x₂ y₂ g.mk' x₁ y₁ = g.mk' x₂ y₂
                                                      theorem Submonoid.LocalizationMap.exists_of_sec_mk' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) (x : M) (y : S) :
                                                      ∃ (c : S), c * ((f.sec (f.mk' x y)).2 * x) = c * (y * (f.sec (f.mk' x y)).1)

                                                      Given a Localization map f : M →* N for a Submonoid S ⊆ M, for all x₁ : M and y₁ ∈ S, if x₂ : M, y₂ ∈ S are such that f x₁ * (f y₁)⁻¹ * f y₂ = f x₂, then there exists c ∈ S such that x₁ * y₂ * c = x₂ * y₁ * c.

                                                      theorem AddSubmonoid.LocalizationMap.exists_of_sec_mk' {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) (x : M) (y : S) :
                                                      ∃ (c : S), c + ((f.sec (f.mk' x y)).2 + x) = c + (y + (f.sec (f.mk' x y)).1)

                                                      Given a Localization map f : M →+ N for a Submonoid S ⊆ M, for all x₁ : M and y₁ ∈ S, if x₂ : M, y₂ ∈ S are such that (f x₁ - f y₁) + f y₂ = f x₂, then there exists c ∈ S such that x₁ + y₂ + c = x₂ + y₁ + c.

                                                      theorem Submonoid.LocalizationMap.mk'_eq_of_eq {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) {a₁ : M} {b₁ : M} {a₂ : S} {b₂ : S} (H : a₂ * b₁ = b₂ * a₁) :
                                                      f.mk' a₁ a₂ = f.mk' b₁ b₂
                                                      theorem AddSubmonoid.LocalizationMap.mk'_eq_of_eq {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) {a₁ : M} {b₁ : M} {a₂ : S} {b₂ : S} (H : a₂ + b₁ = b₂ + a₁) :
                                                      f.mk' a₁ a₂ = f.mk' b₁ b₂
                                                      theorem Submonoid.LocalizationMap.mk'_eq_of_eq' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) {a₁ : M} {b₁ : M} {a₂ : S} {b₂ : S} (H : b₁ * a₂ = a₁ * b₂) :
                                                      f.mk' a₁ a₂ = f.mk' b₁ b₂
                                                      theorem AddSubmonoid.LocalizationMap.mk'_eq_of_eq' {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) {a₁ : M} {b₁ : M} {a₂ : S} {b₂ : S} (H : b₁ + a₂ = a₁ + b₂) :
                                                      f.mk' a₁ a₂ = f.mk' b₁ b₂
                                                      theorem Submonoid.LocalizationMap.mk'_cancel {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) (a : M) (b : S) (c : S) :
                                                      f.mk' (a * c) (b * c) = f.mk' a b
                                                      theorem AddSubmonoid.LocalizationMap.mk'_cancel {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) (a : M) (b : S) (c : S) :
                                                      f.mk' (a + c) (b + c) = f.mk' a b
                                                      theorem Submonoid.LocalizationMap.mk'_eq_of_same {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) {a : M} {b : M} {d : S} :
                                                      f.mk' a d = f.mk' b d ∃ (c : S), c * a = c * b
                                                      theorem AddSubmonoid.LocalizationMap.mk'_eq_of_same {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) {a : M} {b : M} {d : S} :
                                                      f.mk' a d = f.mk' b d ∃ (c : S), c + a = c + b
                                                      @[simp]
                                                      theorem Submonoid.LocalizationMap.mk'_self' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) (y : S) :
                                                      f.mk' (↑y) y = 1
                                                      @[simp]
                                                      theorem AddSubmonoid.LocalizationMap.mk'_self' {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) (y : S) :
                                                      f.mk' (↑y) y = 0
                                                      @[simp]
                                                      theorem Submonoid.LocalizationMap.mk'_self {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) (x : M) (H : x S) :
                                                      f.mk' x x, H = 1
                                                      @[simp]
                                                      theorem AddSubmonoid.LocalizationMap.mk'_self {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) (x : M) (H : x S) :
                                                      f.mk' x x, H = 0
                                                      theorem Submonoid.LocalizationMap.mul_mk'_eq_mk'_of_mul {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) (x₁ : M) (x₂ : M) (y : S) :
                                                      f.toMap x₁ * f.mk' x₂ y = f.mk' (x₁ * x₂) y
                                                      theorem AddSubmonoid.LocalizationMap.add_mk'_eq_mk'_of_add {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) (x₁ : M) (x₂ : M) (y : S) :
                                                      f.toMap x₁ + f.mk' x₂ y = f.mk' (x₁ + x₂) y
                                                      theorem Submonoid.LocalizationMap.mk'_mul_eq_mk'_of_mul {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) (x₁ : M) (x₂ : M) (y : S) :
                                                      f.mk' x₂ y * f.toMap x₁ = f.mk' (x₁ * x₂) y
                                                      theorem AddSubmonoid.LocalizationMap.mk'_add_eq_mk'_of_add {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) (x₁ : M) (x₂ : M) (y : S) :
                                                      f.mk' x₂ y + f.toMap x₁ = f.mk' (x₁ + x₂) y
                                                      theorem Submonoid.LocalizationMap.mul_mk'_one_eq_mk' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) (x : M) (y : S) :
                                                      f.toMap x * f.mk' 1 y = f.mk' x y
                                                      theorem AddSubmonoid.LocalizationMap.add_mk'_zero_eq_mk' {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) (x : M) (y : S) :
                                                      f.toMap x + f.mk' 0 y = f.mk' x y
                                                      @[simp]
                                                      theorem Submonoid.LocalizationMap.mk'_mul_cancel_right {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) (x : M) (y : S) :
                                                      f.mk' (x * y) y = f.toMap x
                                                      @[simp]
                                                      theorem AddSubmonoid.LocalizationMap.mk'_add_cancel_right {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) (x : M) (y : S) :
                                                      f.mk' (x + y) y = f.toMap x
                                                      theorem Submonoid.LocalizationMap.mk'_mul_cancel_left {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) (x : M) (y : S) :
                                                      f.mk' (y * x) y = f.toMap x
                                                      theorem AddSubmonoid.LocalizationMap.mk'_add_cancel_left {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) (x : M) (y : S) :
                                                      f.mk' (y + x) y = f.toMap x
                                                      theorem Submonoid.LocalizationMap.isUnit_comp {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) (j : N →* P) (y : S) :
                                                      IsUnit ((j.comp f.toMap) y)
                                                      theorem AddSubmonoid.LocalizationMap.isAddUnit_comp {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) (j : N →+ P) (y : S) :
                                                      IsAddUnit ((j.comp f.toMap) y)
                                                      theorem Submonoid.LocalizationMap.eq_of_eq {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} (hg : ∀ (y : S), IsUnit (g y)) {x : M} {y : M} (h : f.toMap x = f.toMap y) :
                                                      g x = g y

                                                      Given a Localization map f : M →* N for a Submonoid S ⊆ M and a map of CommMonoids g : M →* P such that g(S) ⊆ Units P, f x = f y → g x = g y for all x y : M.

                                                      theorem AddSubmonoid.LocalizationMap.eq_of_eq {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} (hg : ∀ (y : S), IsAddUnit (g y)) {x : M} {y : M} (h : f.toMap x = f.toMap y) :
                                                      g x = g y

                                                      Given a Localization map f : M →+ N for a Submonoid S ⊆ M and a map of AddCommMonoids g : M →+ P such that g(S) ⊆ AddUnits P, f x = f y → g x = g y for all x y : M.

                                                      theorem Submonoid.LocalizationMap.comp_eq_of_eq {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} {T : Submonoid P} {Q : Type u_4} [CommMonoid Q] (hg : ∀ (y : S), g y T) (k : T.LocalizationMap Q) {x : M} {y : M} (h : f.toMap x = f.toMap y) :
                                                      k.toMap (g x) = k.toMap (g y)

                                                      Given CommMonoids M, P, Localization maps f : M →* N, k : P →* Q for Submonoids S, T respectively, and g : M →* P such that g(S) ⊆ T, f x = f y implies k (g x) = k (g y).

                                                      theorem AddSubmonoid.LocalizationMap.comp_eq_of_eq {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} {T : AddSubmonoid P} {Q : Type u_4} [AddCommMonoid Q] (hg : ∀ (y : S), g y T) (k : T.LocalizationMap Q) {x : M} {y : M} (h : f.toMap x = f.toMap y) :
                                                      k.toMap (g x) = k.toMap (g y)

                                                      Given AddCommMonoids M, P, Localization maps f : M →+ N, k : P →+ Q for Submonoids S, T respectively, and g : M →+ P such that g(S) ⊆ T, f x = f y implies k (g x) = k (g y).

                                                      noncomputable def Submonoid.LocalizationMap.lift {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} (hg : ∀ (y : S), IsUnit (g y)) :
                                                      N →* P

                                                      Given a Localization map f : M →* N for a Submonoid S ⊆ M and a map of CommMonoids g : M →* P such that g y is invertible for all y : S, the homomorphism induced from N to P sending z : N to g x * (g y)⁻¹, where (x, y) : M × S are such that z = f x * (f y)⁻¹.

                                                      Equations
                                                      • f.lift hg = { toFun := fun (z : N) => g (f.sec z).1 * ((IsUnit.liftRight (g.restrict S) hg) (f.sec z).2)⁻¹, map_one' := , map_mul' := }
                                                      Instances For
                                                        noncomputable def AddSubmonoid.LocalizationMap.lift {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} (hg : ∀ (y : S), IsAddUnit (g y)) :
                                                        N →+ P

                                                        Given a localization map f : M →+ N for a submonoid S ⊆ M and a map of AddCommMonoids g : M →+ P such that g y is invertible for all y : S, the homomorphism induced from N to P sending z : N to g x - g y, where (x, y) : M × S are such that z = f x - f y.

                                                        Equations
                                                        • f.lift hg = { toFun := fun (z : N) => g (f.sec z).1 + (-(IsAddUnit.liftRight (g.restrict S) hg) (f.sec z).2), map_zero' := , map_add' := }
                                                        Instances For
                                                          theorem Submonoid.LocalizationMap.lift_mk' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} (hg : ∀ (y : S), IsUnit (g y)) (x : M) (y : S) :
                                                          (f.lift hg) (f.mk' x y) = g x * ((IsUnit.liftRight (g.restrict S) hg) y)⁻¹

                                                          Given a Localization map f : M →* N for a Submonoid S ⊆ M and a map of CommMonoids g : M →* P such that g y is invertible for all y : S, the homomorphism induced from N to P maps f x * (f y)⁻¹ to g x * (g y)⁻¹ for all x : M, y ∈ S.

                                                          theorem AddSubmonoid.LocalizationMap.lift_mk' {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} (hg : ∀ (y : S), IsAddUnit (g y)) (x : M) (y : S) :
                                                          (f.lift hg) (f.mk' x y) = g x + (-(IsAddUnit.liftRight (g.restrict S) hg) y)

                                                          Given a Localization map f : M →+ N for a Submonoid S ⊆ M and a map of AddCommMonoids g : M →+ P such that g y is invertible for all y : S, the homomorphism induced from N to P maps f x - f y to g x - g y for all x : M, y ∈ S.

                                                          theorem Submonoid.LocalizationMap.lift_spec {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} (hg : ∀ (y : S), IsUnit (g y)) (z : N) (v : P) :
                                                          (f.lift hg) z = v g (f.sec z).1 = g (f.sec z).2 * v

                                                          Given a Localization map f : M →* N for a Submonoid S ⊆ M, if a CommMonoid map g : M →* P induces a map f.lift hg : N →* P then for all z : N, v : P, we have f.lift hg z = v ↔ g x = g y * v, where x : M, y ∈ S are such that z * f y = f x.

                                                          theorem AddSubmonoid.LocalizationMap.lift_spec {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} (hg : ∀ (y : S), IsAddUnit (g y)) (z : N) (v : P) :
                                                          (f.lift hg) z = v g (f.sec z).1 = g (f.sec z).2 + v

                                                          Given a Localization map f : M →+ N for a Submonoid S ⊆ M, if an AddCommMonoid map g : M →+ P induces a map f.lift hg : N →+ P then for all z : N, v : P, we have f.lift hg z = v ↔ g x = g y + v, where x : M, y ∈ S are such that z + f y = f x.

                                                          theorem Submonoid.LocalizationMap.lift_spec_mul {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} (hg : ∀ (y : S), IsUnit (g y)) (z : N) (w : P) (v : P) :
                                                          (f.lift hg) z * w = v g (f.sec z).1 * w = g (f.sec z).2 * v

                                                          Given a Localization map f : M →* N for a Submonoid S ⊆ M, if a CommMonoid map g : M →* P induces a map f.lift hg : N →* P then for all z : N, v w : P, we have f.lift hg z * w = v ↔ g x * w = g y * v, where x : M, y ∈ S are such that z * f y = f x.

                                                          theorem AddSubmonoid.LocalizationMap.lift_spec_add {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} (hg : ∀ (y : S), IsAddUnit (g y)) (z : N) (w : P) (v : P) :
                                                          (f.lift hg) z + w = v g (f.sec z).1 + w = g (f.sec z).2 + v

                                                          Given a Localization map f : M →+ N for a Submonoid S ⊆ M, if an AddCommMonoid map g : M →+ P induces a map f.lift hg : N →+ P then for all z : N, v w : P, we have f.lift hg z + w = v ↔ g x + w = g y + v, where x : M, y ∈ S are such that z + f y = f x.

                                                          theorem Submonoid.LocalizationMap.lift_mk'_spec {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} (hg : ∀ (y : S), IsUnit (g y)) (x : M) (v : P) (y : S) :
                                                          (f.lift hg) (f.mk' x y) = v g x = g y * v
                                                          theorem AddSubmonoid.LocalizationMap.lift_mk'_spec {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} (hg : ∀ (y : S), IsAddUnit (g y)) (x : M) (v : P) (y : S) :
                                                          (f.lift hg) (f.mk' x y) = v g x = g y + v
                                                          theorem Submonoid.LocalizationMap.lift_mul_right {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} (hg : ∀ (y : S), IsUnit (g y)) (z : N) :
                                                          (f.lift hg) z * g (f.sec z).2 = g (f.sec z).1

                                                          Given a Localization map f : M →* N for a Submonoid S ⊆ M, if a CommMonoid map g : M →* P induces a map f.lift hg : N →* P then for all z : N, we have f.lift hg z * g y = g x, where x : M, y ∈ S are such that z * f y = f x.

                                                          theorem AddSubmonoid.LocalizationMap.lift_add_right {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} (hg : ∀ (y : S), IsAddUnit (g y)) (z : N) :
                                                          (f.lift hg) z + g (f.sec z).2 = g (f.sec z).1

                                                          Given a Localization map f : M →+ N for a Submonoid S ⊆ M, if an AddCommMonoid map g : M →+ P induces a map f.lift hg : N →+ P then for all z : N, we have f.lift hg z + g y = g x, where x : M, y ∈ S are such that z + f y = f x.

                                                          theorem Submonoid.LocalizationMap.lift_mul_left {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} (hg : ∀ (y : S), IsUnit (g y)) (z : N) :
                                                          g (f.sec z).2 * (f.lift hg) z = g (f.sec z).1

                                                          Given a Localization map f : M →* N for a Submonoid S ⊆ M, if a CommMonoid map g : M →* P induces a map f.lift hg : N →* P then for all z : N, we have g y * f.lift hg z = g x, where x : M, y ∈ S are such that z * f y = f x.

                                                          theorem AddSubmonoid.LocalizationMap.lift_add_left {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} (hg : ∀ (y : S), IsAddUnit (g y)) (z : N) :
                                                          g (f.sec z).2 + (f.lift hg) z = g (f.sec z).1

                                                          Given a Localization map f : M →+ N for a Submonoid S ⊆ M, if an AddCommMonoid map g : M →+ P induces a map f.lift hg : N →+ P then for all z : N, we have g y + f.lift hg z = g x, where x : M, y ∈ S are such that z + f y = f x.

                                                          @[simp]
                                                          theorem Submonoid.LocalizationMap.lift_eq {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} (hg : ∀ (y : S), IsUnit (g y)) (x : M) :
                                                          (f.lift hg) (f.toMap x) = g x
                                                          @[simp]
                                                          theorem AddSubmonoid.LocalizationMap.lift_eq {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} (hg : ∀ (y : S), IsAddUnit (g y)) (x : M) :
                                                          (f.lift hg) (f.toMap x) = g x
                                                          theorem Submonoid.LocalizationMap.lift_eq_iff {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} (hg : ∀ (y : S), IsUnit (g y)) {x : M × S} {y : M × S} :
                                                          (f.lift hg) (f.mk' x.1 x.2) = (f.lift hg) (f.mk' y.1 y.2) g (x.1 * y.2) = g (y.1 * x.2)
                                                          theorem AddSubmonoid.LocalizationMap.lift_eq_iff {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} (hg : ∀ (y : S), IsAddUnit (g y)) {x : M × S} {y : M × S} :
                                                          (f.lift hg) (f.mk' x.1 x.2) = (f.lift hg) (f.mk' y.1 y.2) g (x.1 + y.2) = g (y.1 + x.2)
                                                          @[simp]
                                                          theorem Submonoid.LocalizationMap.lift_comp {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} (hg : ∀ (y : S), IsUnit (g y)) :
                                                          (f.lift hg).comp f.toMap = g
                                                          @[simp]
                                                          theorem AddSubmonoid.LocalizationMap.lift_comp {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} (hg : ∀ (y : S), IsAddUnit (g y)) :
                                                          (f.lift hg).comp f.toMap = g
                                                          @[simp]
                                                          theorem Submonoid.LocalizationMap.lift_of_comp {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) (j : N →* P) :
                                                          f.lift = j
                                                          @[simp]
                                                          theorem AddSubmonoid.LocalizationMap.lift_of_comp {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) (j : N →+ P) :
                                                          f.lift = j
                                                          theorem Submonoid.LocalizationMap.epic_of_localizationMap {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {j : N →* P} {k : N →* P} (h : ∀ (a : M), (j.comp f.toMap) a = (k.comp f.toMap) a) :
                                                          j = k
                                                          theorem AddSubmonoid.LocalizationMap.epic_of_localizationMap {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {j : N →+ P} {k : N →+ P} (h : ∀ (a : M), (j.comp f.toMap) a = (k.comp f.toMap) a) :
                                                          j = k
                                                          theorem Submonoid.LocalizationMap.lift_unique {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} (hg : ∀ (y : S), IsUnit (g y)) {j : N →* P} (hj : ∀ (x : M), j (f.toMap x) = g x) :
                                                          f.lift hg = j
                                                          theorem AddSubmonoid.LocalizationMap.lift_unique {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} (hg : ∀ (y : S), IsAddUnit (g y)) {j : N →+ P} (hj : ∀ (x : M), j (f.toMap x) = g x) :
                                                          f.lift hg = j
                                                          @[simp]
                                                          theorem Submonoid.LocalizationMap.lift_id {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) (x : N) :
                                                          (f.lift ) x = x
                                                          @[simp]
                                                          theorem AddSubmonoid.LocalizationMap.lift_id {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) (x : N) :
                                                          (f.lift ) x = x
                                                          theorem Submonoid.LocalizationMap.lift_comp_lift {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) {T : Submonoid M} (hST : S T) {Q : Type u_4} [CommMonoid Q] (k : T.LocalizationMap Q) {A : Type u_5} [CommMonoid A] {l : M →* A} (hl : ∀ (w : T), IsUnit (l w)) :
                                                          (k.lift hl).comp (f.lift ) = f.lift

                                                          Given Localization maps f : M →* N for a Submonoid S ⊆ M and k : M →* Q for a Submonoid T ⊆ M, such that S ≤ T, and we have l : M →* A, the composition of the induced map f.lift for k with the induced map k.lift for l is equal to the induced map f.lift for l.

                                                          theorem AddSubmonoid.LocalizationMap.lift_comp_lift {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) {T : AddSubmonoid M} (hST : S T) {Q : Type u_4} [AddCommMonoid Q] (k : T.LocalizationMap Q) {A : Type u_5} [AddCommMonoid A] {l : M →+ A} (hl : ∀ (w : T), IsAddUnit (l w)) :
                                                          (k.lift hl).comp (f.lift ) = f.lift

                                                          Given Localization maps f : M →+ N for a Submonoid S ⊆ M and k : M →+ Q for a Submonoid T ⊆ M, such that S ≤ T, and we have l : M →+ A, the composition of the induced map f.lift for k with the induced map k.lift for l is equal to the induced map f.lift for l

                                                          theorem Submonoid.LocalizationMap.lift_comp_lift_eq {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) {Q : Type u_4} [CommMonoid Q] (k : S.LocalizationMap Q) {A : Type u_5} [CommMonoid A] {l : M →* A} (hl : ∀ (w : S), IsUnit (l w)) :
                                                          (k.lift hl).comp (f.lift ) = f.lift hl
                                                          theorem AddSubmonoid.LocalizationMap.lift_comp_lift_eq {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) {Q : Type u_4} [AddCommMonoid Q] (k : S.LocalizationMap Q) {A : Type u_5} [AddCommMonoid A] {l : M →+ A} (hl : ∀ (w : S), IsAddUnit (l w)) :
                                                          (k.lift hl).comp (f.lift ) = f.lift hl
                                                          @[simp]
                                                          theorem Submonoid.LocalizationMap.lift_left_inverse {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {k : S.LocalizationMap P} (z : N) :
                                                          (k.lift ) ((f.lift ) z) = z

                                                          Given two Localization maps f : M →* N, k : M →* P for a Submonoid S ⊆ M, the hom from P to N induced by f is left inverse to the hom from N to P induced by k.

                                                          @[simp]
                                                          theorem AddSubmonoid.LocalizationMap.lift_left_inverse {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {k : S.LocalizationMap P} (z : N) :
                                                          (k.lift ) ((f.lift ) z) = z

                                                          Given two Localization maps f : M →+ N, k : M →+ P for a Submonoid S ⊆ M, the hom from P to N induced by f is left inverse to the hom from N to P induced by k.

                                                          theorem Submonoid.LocalizationMap.lift_surjective_iff {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} (hg : ∀ (y : S), IsUnit (g y)) :
                                                          Function.Surjective (f.lift hg) ∀ (v : P), ∃ (x : M × S), v * g x.2 = g x.1
                                                          theorem AddSubmonoid.LocalizationMap.lift_surjective_iff {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} (hg : ∀ (y : S), IsAddUnit (g y)) :
                                                          Function.Surjective (f.lift hg) ∀ (v : P), ∃ (x : M × S), v + g x.2 = g x.1
                                                          theorem Submonoid.LocalizationMap.lift_injective_iff {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} (hg : ∀ (y : S), IsUnit (g y)) :
                                                          Function.Injective (f.lift hg) ∀ (x y : M), f.toMap x = f.toMap y g x = g y
                                                          theorem AddSubmonoid.LocalizationMap.lift_injective_iff {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} (hg : ∀ (y : S), IsAddUnit (g y)) :
                                                          Function.Injective (f.lift hg) ∀ (x y : M), f.toMap x = f.toMap y g x = g y
                                                          noncomputable def Submonoid.LocalizationMap.map {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} {T : Submonoid P} (hy : ∀ (y : S), g y T) {Q : Type u_4} [CommMonoid Q] (k : T.LocalizationMap Q) :
                                                          N →* Q

                                                          Given a CommMonoid homomorphism g : M →* P where for Submonoids S ⊆ M, T ⊆ P we have g(S) ⊆ T, the induced Monoid homomorphism from the Localization of M at S to the Localization of P at T: if f : M →* N and k : P →* Q are Localization maps for S and T respectively, we send z : N to k (g x) * (k (g y))⁻¹, where (x, y) : M × S are such that z = f x * (f y)⁻¹.

                                                          Equations
                                                          • f.map hy k = f.lift
                                                          Instances For
                                                            noncomputable def AddSubmonoid.LocalizationMap.map {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} {T : AddSubmonoid P} (hy : ∀ (y : S), g y T) {Q : Type u_4} [AddCommMonoid Q] (k : T.LocalizationMap Q) :
                                                            N →+ Q

                                                            Given an AddCommMonoid homomorphism g : M →+ P where for Submonoids S ⊆ M, T ⊆ P we have g(S) ⊆ T, the induced AddMonoid homomorphism from the Localization of M at S to the Localization of P at T: if f : M →+ N and k : P →+ Q are Localization maps for S and T respectively, we send z : N to k (g x) - k (g y), where (x, y) : M × S are such that z = f x - f y.

                                                            Equations
                                                            • f.map hy k = f.lift
                                                            Instances For
                                                              theorem Submonoid.LocalizationMap.map_eq {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} {T : Submonoid P} (hy : ∀ (y : S), g y T) {Q : Type u_4} [CommMonoid Q] {k : T.LocalizationMap Q} (x : M) :
                                                              (f.map hy k) (f.toMap x) = k.toMap (g x)
                                                              theorem AddSubmonoid.LocalizationMap.map_eq {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} {T : AddSubmonoid P} (hy : ∀ (y : S), g y T) {Q : Type u_4} [AddCommMonoid Q] {k : T.LocalizationMap Q} (x : M) :
                                                              (f.map hy k) (f.toMap x) = k.toMap (g x)
                                                              @[simp]
                                                              theorem Submonoid.LocalizationMap.map_comp {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} {T : Submonoid P} (hy : ∀ (y : S), g y T) {Q : Type u_4} [CommMonoid Q] {k : T.LocalizationMap Q} :
                                                              (f.map hy k).comp f.toMap = k.toMap.comp g
                                                              @[simp]
                                                              theorem AddSubmonoid.LocalizationMap.map_comp {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} {T : AddSubmonoid P} (hy : ∀ (y : S), g y T) {Q : Type u_4} [AddCommMonoid Q] {k : T.LocalizationMap Q} :
                                                              (f.map hy k).comp f.toMap = k.toMap.comp g
                                                              theorem Submonoid.LocalizationMap.map_mk' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} {T : Submonoid P} (hy : ∀ (y : S), g y T) {Q : Type u_4} [CommMonoid Q] {k : T.LocalizationMap Q} (x : M) (y : S) :
                                                              (f.map hy k) (f.mk' x y) = k.mk' (g x) g y,
                                                              theorem AddSubmonoid.LocalizationMap.map_mk' {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} {T : AddSubmonoid P} (hy : ∀ (y : S), g y T) {Q : Type u_4} [AddCommMonoid Q] {k : T.LocalizationMap Q} (x : M) (y : S) :
                                                              (f.map hy k) (f.mk' x y) = k.mk' (g x) g y,
                                                              theorem Submonoid.LocalizationMap.map_spec {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} {T : Submonoid P} (hy : ∀ (y : S), g y T) {Q : Type u_4} [CommMonoid Q] {k : T.LocalizationMap Q} (z : N) (u : Q) :
                                                              (f.map hy k) z = u k.toMap (g (f.sec z).1) = k.toMap (g (f.sec z).2) * u

                                                              Given Localization maps f : M →* N, k : P →* Q for Submonoids S, T respectively, if a CommMonoid homomorphism g : M →* P induces a f.map hy k : N →* Q, then for all z : N, u : Q, we have f.map hy k z = u ↔ k (g x) = k (g y) * u where x : M, y ∈ S are such that z * f y = f x.

                                                              theorem AddSubmonoid.LocalizationMap.map_spec {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} {T : AddSubmonoid P} (hy : ∀ (y : S), g y T) {Q : Type u_4} [AddCommMonoid Q] {k : T.LocalizationMap Q} (z : N) (u : Q) :
                                                              (f.map hy k) z = u k.toMap (g (f.sec z).1) = k.toMap (g (f.sec z).2) + u

                                                              Given Localization maps f : M →+ N, k : P →+ Q for Submonoids S, T respectively, if an AddCommMonoid homomorphism g : M →+ P induces a f.map hy k : N →+ Q, then for all z : N, u : Q, we have f.map hy k z = u ↔ k (g x) = k (g y) + u where x : M, y ∈ S are such that z + f y = f x.

                                                              theorem Submonoid.LocalizationMap.map_mul_right {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} {T : Submonoid P} (hy : ∀ (y : S), g y T) {Q : Type u_4} [CommMonoid Q] {k : T.LocalizationMap Q} (z : N) :
                                                              (f.map hy k) z * k.toMap (g (f.sec z).2) = k.toMap (g (f.sec z).1)

                                                              Given Localization maps f : M →* N, k : P →* Q for Submonoids S, T respectively, if a CommMonoid homomorphism g : M →* P induces a f.map hy k : N →* Q, then for all z : N, we have f.map hy k z * k (g y) = k (g x) where x : M, y ∈ S are such that z * f y = f x.

                                                              theorem AddSubmonoid.LocalizationMap.map_add_right {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} {T : AddSubmonoid P} (hy : ∀ (y : S), g y T) {Q : Type u_4} [AddCommMonoid Q] {k : T.LocalizationMap Q} (z : N) :
                                                              (f.map hy k) z + k.toMap (g (f.sec z).2) = k.toMap (g (f.sec z).1)

                                                              Given Localization maps f : M →+ N, k : P →+ Q for Submonoids S, T respectively, if an AddCommMonoid homomorphism g : M →+ P induces a f.map hy k : N →+ Q, then for all z : N, we have f.map hy k z + k (g y) = k (g x) where x : M, y ∈ S are such that z + f y = f x.

                                                              theorem Submonoid.LocalizationMap.map_mul_left {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} {T : Submonoid P} (hy : ∀ (y : S), g y T) {Q : Type u_4} [CommMonoid Q] {k : T.LocalizationMap Q} (z : N) :
                                                              k.toMap (g (f.sec z).2) * (f.map hy k) z = k.toMap (g (f.sec z).1)

                                                              Given Localization maps f : M →* N, k : P →* Q for Submonoids S, T respectively, if a CommMonoid homomorphism g : M →* P induces a f.map hy k : N →* Q, then for all z : N, we have k (g y) * f.map hy k z = k (g x) where x : M, y ∈ S are such that z * f y = f x.

                                                              theorem AddSubmonoid.LocalizationMap.map_add_left {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} {T : AddSubmonoid P} (hy : ∀ (y : S), g y T) {Q : Type u_4} [AddCommMonoid Q] {k : T.LocalizationMap Q} (z : N) :
                                                              k.toMap (g (f.sec z).2) + (f.map hy k) z = k.toMap (g (f.sec z).1)

                                                              Given Localization maps f : M →+ N, k : P →+ Q for Submonoids S, T respectively if an AddCommMonoid homomorphism g : M →+ P induces a f.map hy k : N →+ Q, then for all z : N, we have k (g y) + f.map hy k z = k (g x) where x : M, y ∈ S are such that z + f y = f x.

                                                              @[simp]
                                                              theorem Submonoid.LocalizationMap.map_id {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) (z : N) :
                                                              (f.map f) z = z
                                                              @[simp]
                                                              theorem AddSubmonoid.LocalizationMap.map_id {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) (z : N) :
                                                              (f.map f) z = z
                                                              theorem Submonoid.LocalizationMap.map_comp_map {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} {T : Submonoid P} (hy : ∀ (y : S), g y T) {Q : Type u_4} [CommMonoid Q] {k : T.LocalizationMap Q} {A : Type u_5} [CommMonoid A] {U : Submonoid A} {R : Type u_6} [CommMonoid R] (j : U.LocalizationMap R) {l : P →* A} (hl : ∀ (w : T), l w U) :
                                                              (k.map hl j).comp (f.map hy k) = f.map j

                                                              If CommMonoid homs g : M →* P, l : P →* A induce maps of localizations, the composition of the induced maps equals the map of localizations induced by l ∘ g.

                                                              theorem AddSubmonoid.LocalizationMap.map_comp_map {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} {T : AddSubmonoid P} (hy : ∀ (y : S), g y T) {Q : Type u_4} [AddCommMonoid Q] {k : T.LocalizationMap Q} {A : Type u_5} [AddCommMonoid A] {U : AddSubmonoid A} {R : Type u_6} [AddCommMonoid R] (j : U.LocalizationMap R) {l : P →+ A} (hl : ∀ (w : T), l w U) :
                                                              (k.map hl j).comp (f.map hy k) = f.map j

                                                              If AddCommMonoid homs g : M →+ P, l : P →+ A induce maps of localizations, the composition of the induced maps equals the map of localizations induced by l ∘ g.

                                                              theorem Submonoid.LocalizationMap.map_map {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} {T : Submonoid P} (hy : ∀ (y : S), g y T) {Q : Type u_4} [CommMonoid Q] {k : T.LocalizationMap Q} {A : Type u_5} [CommMonoid A] {U : Submonoid A} {R : Type u_6} [CommMonoid R] (j : U.LocalizationMap R) {l : P →* A} (hl : ∀ (w : T), l w U) (x : N) :
                                                              (k.map hl j) ((f.map hy k) x) = (f.map j) x

                                                              If CommMonoid homs g : M →* P, l : P →* A induce maps of localizations, the composition of the induced maps equals the map of localizations induced by l ∘ g.

                                                              theorem AddSubmonoid.LocalizationMap.map_map {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} {T : AddSubmonoid P} (hy : ∀ (y : S), g y T) {Q : Type u_4} [AddCommMonoid Q] {k : T.LocalizationMap Q} {A : Type u_5} [AddCommMonoid A] {U : AddSubmonoid A} {R : Type u_6} [AddCommMonoid R] (j : U.LocalizationMap R) {l : P →+ A} (hl : ∀ (w : T), l w U) (x : N) :
                                                              (k.map hl j) ((f.map hy k) x) = (f.map j) x

                                                              If AddCommMonoid homs g : M →+ P, l : P →+ A induce maps of localizations, the composition of the induced maps equals the map of localizations induced by l ∘ g.

                                                              theorem Submonoid.LocalizationMap.map_injective_of_injective {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} {Q : Type u_4} [CommMonoid Q] (hg : Function.Injective g) (k : (Submonoid.map g S).LocalizationMap Q) :
                                                              Function.Injective (f.map k)

                                                              Given an injective CommMonoid homomorphism g : M →* P, and a submonoid S ⊆ M, the induced monoid homomorphism from the localization of M at S to the localization of P at g S, is injective.

                                                              theorem AddSubmonoid.LocalizationMap.map_injective_of_injective {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} {Q : Type u_4} [AddCommMonoid Q] (hg : Function.Injective g) (k : (AddSubmonoid.map g S).LocalizationMap Q) :
                                                              Function.Injective (f.map k)

                                                              Given an injective AddCommMonoid homomorphism g : M →+ P, and a submonoid S ⊆ M, the induced monoid homomorphism from the localization of M at S to the localization of P at g S, is injective.

                                                              theorem Submonoid.LocalizationMap.map_surjective_of_surjective {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} {Q : Type u_4} [CommMonoid Q] (hg : Function.Surjective g) (k : (Submonoid.map g S).LocalizationMap Q) :
                                                              Function.Surjective (f.map k)

                                                              Given a surjective CommMonoid homomorphism g : M →* P, and a submonoid S ⊆ M, the induced monoid homomorphism from the localization of M at S to the localization of P at g S, is surjective.

                                                              theorem AddSubmonoid.LocalizationMap.map_surjective_of_surjective {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} {Q : Type u_4} [AddCommMonoid Q] (hg : Function.Surjective g) (k : (AddSubmonoid.map g S).LocalizationMap Q) :
                                                              Function.Surjective (f.map k)

                                                              Given a surjective AddCommMonoid homomorphism g : M →+ P, and a submonoid S ⊆ M, the induced monoid homomorphism from the localization of M at S to the localization of P at g S, is surjective.

                                                              noncomputable def Submonoid.LocalizationMap.mulEquivOfLocalizations {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) (k : S.LocalizationMap P) :
                                                              N ≃* P

                                                              If f : M →* N and k : M →* P are Localization maps for a Submonoid S, we get an isomorphism of N and P.

                                                              Equations
                                                              • f.mulEquivOfLocalizations k = { toFun := (f.lift ), invFun := (k.lift ), left_inv := , right_inv := , map_mul' := }
                                                              Instances For
                                                                noncomputable def AddSubmonoid.LocalizationMap.addEquivOfLocalizations {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) (k : S.LocalizationMap P) :
                                                                N ≃+ P

                                                                If f : M →+ N and k : M →+ R are Localization maps for an AddSubmonoid S, we get an isomorphism of N and R.

                                                                Equations
                                                                • f.addEquivOfLocalizations k = { toFun := (f.lift ), invFun := (k.lift ), left_inv := , right_inv := , map_add' := }
                                                                Instances For
                                                                  @[simp]
                                                                  theorem Submonoid.LocalizationMap.mulEquivOfLocalizations_apply {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {k : S.LocalizationMap P} {x : N} :
                                                                  (f.mulEquivOfLocalizations k) x = (f.lift ) x
                                                                  @[simp]
                                                                  theorem AddSubmonoid.LocalizationMap.addEquivOfLocalizations_apply {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {k : S.LocalizationMap P} {x : N} :
                                                                  (f.addEquivOfLocalizations k) x = (f.lift ) x
                                                                  @[simp]
                                                                  theorem Submonoid.LocalizationMap.mulEquivOfLocalizations_symm_apply {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {k : S.LocalizationMap P} {x : P} :
                                                                  (f.mulEquivOfLocalizations k).symm x = (k.lift ) x
                                                                  @[simp]
                                                                  theorem AddSubmonoid.LocalizationMap.addEquivOfLocalizations_symm_apply {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {k : S.LocalizationMap P} {x : P} :
                                                                  (f.addEquivOfLocalizations k).symm x = (k.lift ) x
                                                                  theorem Submonoid.LocalizationMap.mulEquivOfLocalizations_symm_eq_mulEquivOfLocalizations {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {k : S.LocalizationMap P} :
                                                                  (k.mulEquivOfLocalizations f).symm = f.mulEquivOfLocalizations k
                                                                  theorem AddSubmonoid.LocalizationMap.addEquivOfLocalizations_symm_eq_addEquivOfLocalizations {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {k : S.LocalizationMap P} :
                                                                  (k.addEquivOfLocalizations f).symm = f.addEquivOfLocalizations k
                                                                  def Submonoid.LocalizationMap.ofMulEquivOfLocalizations {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) (k : N ≃* P) :
                                                                  S.LocalizationMap P

                                                                  If f : M →* N is a Localization map for a Submonoid S and k : N ≃* P is an isomorphism of CommMonoids, k ∘ f is a Localization map for M at S.

                                                                  Equations
                                                                  • f.ofMulEquivOfLocalizations k = (k.toMonoidHom.comp f.toMap).toLocalizationMap
                                                                  Instances For
                                                                    def AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) (k : N ≃+ P) :
                                                                    S.LocalizationMap P

                                                                    If f : M →+ N is a Localization map for a Submonoid S and k : N ≃+ P is an isomorphism of AddCommMonoids, k ∘ f is a Localization map for M at S.

                                                                    Equations
                                                                    • f.ofAddEquivOfLocalizations k = (k.toAddMonoidHom.comp f.toMap).toLocalizationMap
                                                                    Instances For
                                                                      @[simp]
                                                                      theorem Submonoid.LocalizationMap.ofMulEquivOfLocalizations_apply {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {k : N ≃* P} (x : M) :
                                                                      (f.ofMulEquivOfLocalizations k).toMap x = k (f.toMap x)
                                                                      @[simp]
                                                                      theorem AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations_apply {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {k : N ≃+ P} (x : M) :
                                                                      (f.ofAddEquivOfLocalizations k).toMap x = k (f.toMap x)
                                                                      theorem Submonoid.LocalizationMap.ofMulEquivOfLocalizations_eq {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {k : N ≃* P} :
                                                                      (f.ofMulEquivOfLocalizations k).toMap = k.toMonoidHom.comp f.toMap
                                                                      theorem AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations_eq {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {k : N ≃+ P} :
                                                                      (f.ofAddEquivOfLocalizations k).toMap = k.toAddMonoidHom.comp f.toMap
                                                                      theorem Submonoid.LocalizationMap.symm_comp_ofMulEquivOfLocalizations_apply {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {k : N ≃* P} (x : M) :
                                                                      k.symm ((f.ofMulEquivOfLocalizations k).toMap x) = f.toMap x
                                                                      theorem AddSubmonoid.LocalizationMap.symm_comp_ofAddEquivOfLocalizations_apply {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {k : N ≃+ P} (x : M) :
                                                                      k.symm ((f.ofAddEquivOfLocalizations k).toMap x) = f.toMap x
                                                                      theorem Submonoid.LocalizationMap.symm_comp_ofMulEquivOfLocalizations_apply' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {k : P ≃* N} (x : M) :
                                                                      k ((f.ofMulEquivOfLocalizations k.symm).toMap x) = f.toMap x
                                                                      theorem AddSubmonoid.LocalizationMap.symm_comp_ofAddEquivOfLocalizations_apply' {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {k : P ≃+ N} (x : M) :
                                                                      k ((f.ofAddEquivOfLocalizations k.symm).toMap x) = f.toMap x
                                                                      theorem Submonoid.LocalizationMap.ofMulEquivOfLocalizations_eq_iff_eq {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {k : N ≃* P} {x : M} {y : P} :
                                                                      (f.ofMulEquivOfLocalizations k).toMap x = y f.toMap x = k.symm y
                                                                      theorem AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations_eq_iff_eq {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {k : N ≃+ P} {x : M} {y : P} :
                                                                      (f.ofAddEquivOfLocalizations k).toMap x = y f.toMap x = k.symm y
                                                                      theorem Submonoid.LocalizationMap.mulEquivOfLocalizations_right_inv {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) (k : S.LocalizationMap P) :
                                                                      f.ofMulEquivOfLocalizations (f.mulEquivOfLocalizations k) = k
                                                                      theorem AddSubmonoid.LocalizationMap.addEquivOfLocalizations_right_inv {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) (k : S.LocalizationMap P) :
                                                                      f.ofAddEquivOfLocalizations (f.addEquivOfLocalizations k) = k
                                                                      theorem Submonoid.LocalizationMap.mulEquivOfLocalizations_right_inv_apply {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {k : S.LocalizationMap P} {x : M} :
                                                                      (f.ofMulEquivOfLocalizations (f.mulEquivOfLocalizations k)).toMap x = k.toMap x
                                                                      theorem AddSubmonoid.LocalizationMap.addEquivOfLocalizations_right_inv_apply {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {k : S.LocalizationMap P} {x : M} :
                                                                      (f.ofAddEquivOfLocalizations (f.addEquivOfLocalizations k)).toMap x = k.toMap x
                                                                      theorem Submonoid.LocalizationMap.mulEquivOfLocalizations_left_inv {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) (k : N ≃* P) :
                                                                      f.mulEquivOfLocalizations (f.ofMulEquivOfLocalizations k) = k
                                                                      theorem AddSubmonoid.LocalizationMap.addEquivOfLocalizations_left_neg {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) (k : N ≃+ P) :
                                                                      f.addEquivOfLocalizations (f.ofAddEquivOfLocalizations k) = k
                                                                      theorem Submonoid.LocalizationMap.mulEquivOfLocalizations_left_inv_apply {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {k : N ≃* P} (x : N) :
                                                                      (f.mulEquivOfLocalizations (f.ofMulEquivOfLocalizations k)) x = k x
                                                                      theorem AddSubmonoid.LocalizationMap.addEquivOfLocalizations_left_neg_apply {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {k : N ≃+ P} (x : N) :
                                                                      (f.addEquivOfLocalizations (f.ofAddEquivOfLocalizations k)) x = k x
                                                                      @[simp]
                                                                      theorem Submonoid.LocalizationMap.ofMulEquivOfLocalizations_id {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) :
                                                                      f.ofMulEquivOfLocalizations (MulEquiv.refl N) = f
                                                                      @[simp]
                                                                      theorem AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations_id {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) :
                                                                      f.ofAddEquivOfLocalizations (AddEquiv.refl N) = f
                                                                      theorem Submonoid.LocalizationMap.ofMulEquivOfLocalizations_comp {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {Q : Type u_4} [CommMonoid Q] {k : N ≃* P} {j : P ≃* Q} :
                                                                      (f.ofMulEquivOfLocalizations (k.trans j)).toMap = j.toMonoidHom.comp (f.ofMulEquivOfLocalizations k).toMap
                                                                      theorem AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations_comp {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {Q : Type u_4} [AddCommMonoid Q] {k : N ≃+ P} {j : P ≃+ Q} :
                                                                      (f.ofAddEquivOfLocalizations (k.trans j)).toMap = j.toAddMonoidHom.comp (f.ofAddEquivOfLocalizations k).toMap
                                                                      def Submonoid.LocalizationMap.ofMulEquivOfDom {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {T : Submonoid P} {k : P ≃* M} (H : Submonoid.map k.toMonoidHom T = S) :
                                                                      T.LocalizationMap N

                                                                      Given CommMonoids M, P and Submonoids S ⊆ M, T ⊆ P, if f : M →* N is a Localization map for S and k : P ≃* M is an isomorphism of CommMonoids such that k(T) = S, f ∘ k is a Localization map for T.

                                                                      Equations
                                                                      • f.ofMulEquivOfDom H = (f.toMap.comp k.toMonoidHom).toLocalizationMap
                                                                      Instances For
                                                                        def AddSubmonoid.LocalizationMap.ofAddEquivOfDom {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {T : AddSubmonoid P} {k : P ≃+ M} (H : AddSubmonoid.map k.toAddMonoidHom T = S) :
                                                                        T.LocalizationMap N

                                                                        Given AddCommMonoids M, P and AddSubmonoids S ⊆ M, T ⊆ P, if f : M →* N is a Localization map for S and k : P ≃+ M is an isomorphism of AddCommMonoids such that k(T) = S, f ∘ k is a Localization map for T.

                                                                        Equations
                                                                        • f.ofAddEquivOfDom H = (f.toMap.comp k.toAddMonoidHom).toLocalizationMap
                                                                        Instances For
                                                                          @[simp]
                                                                          theorem Submonoid.LocalizationMap.ofMulEquivOfDom_apply {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {T : Submonoid P} {k : P ≃* M} (H : Submonoid.map k.toMonoidHom T = S) (x : P) :
                                                                          (f.ofMulEquivOfDom H).toMap x = f.toMap (k x)
                                                                          @[simp]
                                                                          theorem AddSubmonoid.LocalizationMap.ofAddEquivOfDom_apply {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {T : AddSubmonoid P} {k : P ≃+ M} (H : AddSubmonoid.map k.toAddMonoidHom T = S) (x : P) :
                                                                          (f.ofAddEquivOfDom H).toMap x = f.toMap (k x)
                                                                          theorem Submonoid.LocalizationMap.ofMulEquivOfDom_eq {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {T : Submonoid P} {k : P ≃* M} (H : Submonoid.map k.toMonoidHom T = S) :
                                                                          (f.ofMulEquivOfDom H).toMap = f.toMap.comp k.toMonoidHom
                                                                          theorem AddSubmonoid.LocalizationMap.ofAddEquivOfDom_eq {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {T : AddSubmonoid P} {k : P ≃+ M} (H : AddSubmonoid.map k.toAddMonoidHom T = S) :
                                                                          (f.ofAddEquivOfDom H).toMap = f.toMap.comp k.toAddMonoidHom
                                                                          theorem Submonoid.LocalizationMap.ofMulEquivOfDom_comp_symm {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {T : Submonoid P} {k : P ≃* M} (H : Submonoid.map k.toMonoidHom T = S) (x : M) :
                                                                          (f.ofMulEquivOfDom H).toMap (k.symm x) = f.toMap x
                                                                          theorem AddSubmonoid.LocalizationMap.ofAddEquivOfDom_comp_symm {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {T : AddSubmonoid P} {k : P ≃+ M} (H : AddSubmonoid.map k.toAddMonoidHom T = S) (x : M) :
                                                                          (f.ofAddEquivOfDom H).toMap (k.symm x) = f.toMap x
                                                                          theorem Submonoid.LocalizationMap.ofMulEquivOfDom_comp {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {T : Submonoid P} {k : M ≃* P} (H : Submonoid.map k.symm.toMonoidHom T = S) (x : M) :
                                                                          (f.ofMulEquivOfDom H).toMap (k x) = f.toMap x
                                                                          theorem AddSubmonoid.LocalizationMap.ofAddEquivOfDom_comp {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {T : AddSubmonoid P} {k : M ≃+ P} (H : AddSubmonoid.map k.symm.toAddMonoidHom T = S) (x : M) :
                                                                          (f.ofAddEquivOfDom H).toMap (k x) = f.toMap x
                                                                          @[simp]
                                                                          theorem Submonoid.LocalizationMap.ofMulEquivOfDom_id {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N) :
                                                                          f.ofMulEquivOfDom = f

                                                                          A special case of f ∘ id = f, f a Localization map.

                                                                          @[simp]
                                                                          theorem AddSubmonoid.LocalizationMap.ofAddEquivOfDom_id {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : S.LocalizationMap N) :
                                                                          f.ofAddEquivOfDom = f

                                                                          A special case of f ∘ id = f, f a Localization map.

                                                                          noncomputable def Submonoid.LocalizationMap.mulEquivOfMulEquiv {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {T : Submonoid P} {Q : Type u_4} [CommMonoid Q] (k : T.LocalizationMap Q) {j : M ≃* P} (H : Submonoid.map j.toMonoidHom S = T) :
                                                                          N ≃* Q

                                                                          Given Localization maps f : M →* N, k : P →* U for Submonoids S, T respectively, an isomorphism j : M ≃* P such that j(S) = T induces an isomorphism of localizations N ≃* U.

                                                                          Equations
                                                                          • f.mulEquivOfMulEquiv k H = f.mulEquivOfLocalizations (k.ofMulEquivOfDom H)
                                                                          Instances For
                                                                            noncomputable def AddSubmonoid.LocalizationMap.addEquivOfAddEquiv {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {T : AddSubmonoid P} {Q : Type u_4} [AddCommMonoid Q] (k : T.LocalizationMap Q) {j : M ≃+ P} (H : AddSubmonoid.map j.toAddMonoidHom S = T) :
                                                                            N ≃+ Q

                                                                            Given Localization maps f : M →+ N, k : P →+ U for Submonoids S, T respectively, an isomorphism j : M ≃+ P such that j(S) = T induces an isomorphism of localizations N ≃+ U.

                                                                            Equations
                                                                            • f.addEquivOfAddEquiv k H = f.addEquivOfLocalizations (k.ofAddEquivOfDom H)
                                                                            Instances For
                                                                              @[simp]
                                                                              theorem Submonoid.LocalizationMap.mulEquivOfMulEquiv_eq_map_apply {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {T : Submonoid P} {Q : Type u_4} [CommMonoid Q] {k : T.LocalizationMap Q} {j : M ≃* P} (H : Submonoid.map j.toMonoidHom S = T) (x : N) :
                                                                              (f.mulEquivOfMulEquiv k H) x = (f.map k) x
                                                                              @[simp]
                                                                              theorem AddSubmonoid.LocalizationMap.addEquivOfAddEquiv_eq_map_apply {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {T : AddSubmonoid P} {Q : Type u_4} [AddCommMonoid Q] {k : T.LocalizationMap Q} {j : M ≃+ P} (H : AddSubmonoid.map j.toAddMonoidHom S = T) (x : N) :
                                                                              (f.addEquivOfAddEquiv k H) x = (f.map k) x
                                                                              theorem Submonoid.LocalizationMap.mulEquivOfMulEquiv_eq_map {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {T : Submonoid P} {Q : Type u_4} [CommMonoid Q] {k : T.LocalizationMap Q} {j : M ≃* P} (H : Submonoid.map j.toMonoidHom S = T) :
                                                                              (f.mulEquivOfMulEquiv k H).toMonoidHom = f.map k
                                                                              theorem AddSubmonoid.LocalizationMap.addEquivOfAddEquiv_eq_map {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {T : AddSubmonoid P} {Q : Type u_4} [AddCommMonoid Q] {k : T.LocalizationMap Q} {j : M ≃+ P} (H : AddSubmonoid.map j.toAddMonoidHom S = T) :
                                                                              (f.addEquivOfAddEquiv k H).toAddMonoidHom = f.map k
                                                                              @[simp]
                                                                              theorem Submonoid.LocalizationMap.mulEquivOfMulEquiv_eq {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {T : Submonoid P} {Q : Type u_4} [CommMonoid Q] {k : T.LocalizationMap Q} {j : M ≃* P} (H : Submonoid.map j.toMonoidHom S = T) (x : M) :
                                                                              (f.mulEquivOfMulEquiv k H) (f.toMap x) = k.toMap (j x)
                                                                              @[simp]
                                                                              theorem AddSubmonoid.LocalizationMap.addEquivOfAddEquiv_eq {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {T : AddSubmonoid P} {Q : Type u_4} [AddCommMonoid Q] {k : T.LocalizationMap Q} {j : M ≃+ P} (H : AddSubmonoid.map j.toAddMonoidHom S = T) (x : M) :
                                                                              (f.addEquivOfAddEquiv k H) (f.toMap x) = k.toMap (j x)
                                                                              @[simp]
                                                                              theorem Submonoid.LocalizationMap.mulEquivOfMulEquiv_mk' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {T : Submonoid P} {Q : Type u_4} [CommMonoid Q] {k : T.LocalizationMap Q} {j : M ≃* P} (H : Submonoid.map j.toMonoidHom S = T) (x : M) (y : S) :
                                                                              (f.mulEquivOfMulEquiv k H) (f.mk' x y) = k.mk' (j x) j y,
                                                                              @[simp]
                                                                              theorem AddSubmonoid.LocalizationMap.addEquivOfAddEquiv_mk' {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {T : AddSubmonoid P} {Q : Type u_4} [AddCommMonoid Q] {k : T.LocalizationMap Q} {j : M ≃+ P} (H : AddSubmonoid.map j.toAddMonoidHom S = T) (x : M) (y : S) :
                                                                              (f.addEquivOfAddEquiv k H) (f.mk' x y) = k.mk' (j x) j y,
                                                                              @[simp]
                                                                              theorem Submonoid.LocalizationMap.of_mulEquivOfMulEquiv_apply {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {T : Submonoid P} {Q : Type u_4} [CommMonoid Q] {k : T.LocalizationMap Q} {j : M ≃* P} (H : Submonoid.map j.toMonoidHom S = T) (x : M) :
                                                                              (f.ofMulEquivOfLocalizations (f.mulEquivOfMulEquiv k H)).toMap x = k.toMap (j x)
                                                                              @[simp]
                                                                              theorem AddSubmonoid.LocalizationMap.of_addEquivOfAddEquiv_apply {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {T : AddSubmonoid P} {Q : Type u_4} [AddCommMonoid Q] {k : T.LocalizationMap Q} {j : M ≃+ P} (H : AddSubmonoid.map j.toAddMonoidHom S = T) (x : M) :
                                                                              (f.ofAddEquivOfLocalizations (f.addEquivOfAddEquiv k H)).toMap x = k.toMap (j x)
                                                                              theorem Submonoid.LocalizationMap.of_mulEquivOfMulEquiv {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {T : Submonoid P} {Q : Type u_4} [CommMonoid Q] {k : T.LocalizationMap Q} {j : M ≃* P} (H : Submonoid.map j.toMonoidHom S = T) :
                                                                              (f.ofMulEquivOfLocalizations (f.mulEquivOfMulEquiv k H)).toMap = k.toMap.comp j.toMonoidHom
                                                                              theorem AddSubmonoid.LocalizationMap.of_addEquivOfAddEquiv {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {T : AddSubmonoid P} {Q : Type u_4} [AddCommMonoid Q] {k : T.LocalizationMap Q} {j : M ≃+ P} (H : AddSubmonoid.map j.toAddMonoidHom S = T) :
                                                                              (f.ofAddEquivOfLocalizations (f.addEquivOfAddEquiv k H)).toMap = k.toMap.comp j.toAddMonoidHom
                                                                              def Localization.monoidOf {M : Type u_1} [CommMonoid M] (S : Submonoid M) :
                                                                              S.LocalizationMap (Localization S)

                                                                              Natural homomorphism sending x : M, M a CommMonoid, to the equivalence class of (x, 1) in the Localization of M at a Submonoid.

                                                                              Equations
                                                                              Instances For
                                                                                def AddLocalization.addMonoidOf {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) :
                                                                                S.LocalizationMap (AddLocalization S)

                                                                                Natural homomorphism sending x : M, M an AddCommMonoid, to the equivalence class of (x, 0) in the Localization of M at a Submonoid.

                                                                                Equations
                                                                                Instances For
                                                                                  theorem Localization.mk_eq_monoidOf_mk'_apply {M : Type u_1} [CommMonoid M] {S : Submonoid M} (x : M) (y : S) :
                                                                                  theorem Localization.mk_eq_monoidOf_mk' {M : Type u_1} [CommMonoid M] {S : Submonoid M} :
                                                                                  Localization.mk = (Localization.monoidOf S).mk'
                                                                                  @[simp]