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, f x = f y iff there exists c ∈ S such that x * c = y * c.

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 treat the special case of localizing away from an element in the sections AwayMap and Away.

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

• Show that the localization at the top monoid is a group.
• Generalise to (nonempty) subsemigroups.
• If we acquire more bundlings, we can make Localization.mkOrderEmbedding be an ordered monoid embedding.

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 : Type (max u_1 u_2)

• toFun : M → N
• map_zero' : ZeroHom.toFun (↑s.toAddMonoidHom) 0 = 0
• map_add' : ∀ (x y : M), ZeroHom.toFun (↑s.toAddMonoidHom) (x + y) = ZeroHom.toFun (↑s.toAddMonoidHom) x + ZeroHom.toFun (↑s.toAddMonoidHom) y
• map_add_units' : ∀ (y : { x // x ∈ S }), IsAddUnit (ZeroHom.toFun ↑s.toAddMonoidHom ↑y)
• surj' : ∀ (z : N), ∃ x, z + ZeroHom.toFun ↑s.toAddMonoidHom ↑x.snd = ZeroHom.toFun (↑s.toAddMonoidHom) x.fst
• eq_iff_exists' : ∀ (x y : M), ZeroHom.toFun (↑s.toAddMonoidHom) x = ZeroHom.toFun (↑s.toAddMonoidHom) y ↔ ∃ c, ↑c + x = ↑c + y

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.

structure Submonoid.LocalizationMap {M : Type u_1} [CommMonoid M] (S : Submonoid M) (N : Type u_2) [CommMonoid N] extends MonoidHom : Type (max u_1 u_2)

• toFun : M → N
• map_one' : OneHom.toFun (↑s.toMonoidHom) 1 = 1
• map_mul' : ∀ (x y : M), OneHom.toFun (↑s.toMonoidHom) (x * y) = OneHom.toFun (↑s.toMonoidHom) x * OneHom.toFun (↑s.toMonoidHom) y
• map_units' : ∀ (y : { x // x ∈ S }), IsUnit (OneHom.toFun ↑s.toMonoidHom ↑y)
• surj' : ∀ (z : N), ∃ x, z * OneHom.toFun ↑s.toMonoidHom ↑x.snd = OneHom.toFun (↑s.toMonoidHom) x.fst
• eq_iff_exists' : ∀ (x y : M), OneHom.toFun (↑s.toMonoidHom) x = OneHom.toFun (↑s.toMonoidHom) y ↔ ∃ c, ↑c * x = ↑c * y

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.

def AddLocalization.r {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) : AddCon (M × { x // x ∈ S })

The congruence relation on M × S, M an AddCommMonoid and S an add_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, (0, 0) ∼ (y, y) under s, we have that (x₁, y₁) ∼ (x₂, y₂) by r implies (x₁, y₁) ∼ (x₂, y₂) by s.

Equations

• AddLocalization.r S = sInf {c | ∀ (y : { x // x ∈ S }), ↑c 0 (↑y, y)}

def Localization.r {M : Type u_1} [CommMonoid M] (S : Submonoid M) : Con (M × { x // x ∈ 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

• Localization.r S = sInf {c | ∀ (y : { x // x ∈ S }), ↑c 1 (↑y, y)}

abbrev AddLocalization.r'.match_1 {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) : ∀ {x y : M × { x // x ∈ S }} (motive : (∃ c, ↑c + (↑y.snd + x.fst) = ↑c + (↑x.snd + y.fst)) → Prop) (x_1 : ∃ c, ↑c + (↑y.snd + x.fst) = ↑c + (↑x.snd + y.fst)), (∀ (c : { x // x ∈ S }) (hc : ↑c + (↑y.snd + x.fst) = ↑c + (↑x.snd + y.fst)), motive (_ : ∃ c, ↑c + (↑y.snd + x.fst) = ↑c + (↑x.snd + y.fst))) → motive x_1

Equations

• AddLocalization.r'.match_1 S motive x h_1 = Exists.casesOn x fun w h => h_1 w h

theorem AddLocalization.r'.proof_1 {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) : Equivalence fun a b => ∃ c, ↑c + (↑b.snd + a.fst) = ↑c + (↑a.snd + b.fst)

def AddLocalization.r' {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) : AddCon (M × { x // x ∈ 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

• One or more equations did not get rendered due to their size.

theorem AddLocalization.r'.proof_2 {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) {a : M × { x // x ∈ S }} {b : M × { x // x ∈ S }} {c : M × { x // x ∈ S }} {d : M × { x // x ∈ S }} : Setoid.r a b → Setoid.r c d → Setoid.r (a + c) (b + d)

def Localization.r' {M : Type u_1} [CommMonoid M] (S : Submonoid M) : Con (M × { x // x ∈ 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

• One or more equations did not get rendered due to their size.

abbrev AddLocalization.r_eq_r'.match_1 {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) (p : M) (q : { x // x ∈ S }) (x : M) (y : { x // x ∈ S }) (motive : ↑(AddLocalization.r' S) (p, q) (x, y) → Prop) : (x : ↑(AddLocalization.r' S) (p, q) (x, y)) → ((t : { x // x ∈ S }) → (ht : ↑t + (↑(x, y).snd + (p, q).fst) = ↑t + (↑(p, q).snd + (x, y).fst)) → motive (_ : ∃ c, ↑c + (↑(x, y).snd + (p, q).fst) = ↑c + (↑(p, q).snd + (x, y).fst))) → motive x

Equations

• AddLocalization.r_eq_r'.match_1 S p q x y motive x h_1 = Exists.casesOn x fun w h => h_1 w h

theorem AddLocalization.r_eq_r' {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) : AddLocalization.r S = AddLocalization.r' S

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').

abbrev AddLocalization.r_eq_r'.match_3 {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) : (x : M × { x // x ∈ S }) → (motive : (x_1 : M × { x // x ∈ S }) → ↑(AddLocalization.r' S) x_1 x → Prop) → ∀ (x_1 : M × { x // x ∈ S }) (x_2 : ↑(AddLocalization.r' S) x_1 x), (∀ (p : M) (q : { x // x ∈ S }) (x : ↑(AddLocalization.r' S) (p, q) x), motive (p, q) x) → motive x_1 x_2

Equations

• AddLocalization.r_eq_r'.match_3 S x motive x x h_1 = Prod.casesOn M { x // x ∈ S } (fun x => (x_1 : ↑(AddLocalization.r' S) x x) → motive x x_1) x (fun fst snd x => h_1 fst snd x) x

abbrev AddLocalization.r_eq_r'.match_2 {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) (p : M) (q : { x // x ∈ S }) (motive : (x : M × { x // x ∈ S }) → ↑(AddLocalization.r' S) (p, q) x → Prop) : (x : M × { x // x ∈ S }) → (x_1 : ↑(AddLocalization.r' S) (p, q) x) → ((x : M) → (y : { x // x ∈ S }) → (x_2 : ↑(AddLocalization.r' S) (p, q) (x, y)) → motive (x, y) x_2) → motive x x_1

Equations

• AddLocalization.r_eq_r'.match_2 S p q motive x x h_1 = Prod.casesOn M { x // x ∈ S } (fun x => (x_1 : ↑(AddLocalization.r' S) (p, q) x) → motive x x_1) x (fun fst snd x => h_1 fst snd x) x

theorem Localization.r_eq_r' {M : Type u_1} [CommMonoid M] (S : Submonoid M) : Localization.r S = Localization.r' S

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').

theorem AddLocalization.r_iff_exists {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {x : M × { x // x ∈ S }} {y : M × { x // x ∈ S }} : ↑(AddLocalization.r S) x y ↔ ∃ c, ↑c + (↑y.snd + x.fst) = ↑c + (↑x.snd + y.fst)

theorem Localization.r_iff_exists {M : Type u_1} [CommMonoid M] {S : Submonoid M} {x : M × { x // x ∈ S }} {y : M × { x // x ∈ S }} : ↑(Localization.r S) x y ↔ ∃ c, ↑c * (↑y.snd * x.fst) = ↑c * (↑x.snd * y.fst)

def 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

• AddLocalization S = AddCon.Quotient (AddLocalization.r S)

def 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

• Localization S = Con.Quotient (Localization.r S)

instance AddLocalization.inhabited {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) : Inhabited (AddLocalization S)

Equations

• AddLocalization.inhabited S = AddCon.Quotient.inhabited

instance Localization.inhabited {M : Type u_1} [CommMonoid M] (S : Submonoid M) : Inhabited (Localization S)

Equations

• Localization.inhabited S = Con.Quotient.inhabited

theorem Localization.mul_def {M : Type u_4} [CommMonoid M] (S : Submonoid M) : Localization.mul S = Mul.mul

@[irreducible]

def Localization.mul {M : Type u_4} [CommMonoid M] (S : Submonoid M) : Localization S → Localization S → Localization S

Multiplication in a Localization is defined as ⟨a, b⟩ * ⟨c, d⟩ = ⟨a * c, b * d⟩.

Equations

• @Localization.mul = Localization.wrapped✝.1

def AddLocalization.add {M : Type u_4} [AddCommMonoid M] (S : AddSubmonoid M) : AddLocalization S → AddLocalization S → AddLocalization S

Addition in an AddLocalization is defined as ⟨a, b⟩ + ⟨c, d⟩ = ⟨a + c, b + d⟩. Should not be confused with the ring localization counterpart Localization.add, which maps ⟨a, b⟩ + ⟨c, d⟩ to ⟨d * a + b * c, b * d⟩.

Equations

• @AddLocalization.add = Localization.wrapped✝.1

theorem AddLocalization.add_def {M : Type u_4} [AddCommMonoid M] (S : AddSubmonoid M) : AddLocalization.add S = Add.add

Addition in an AddLocalization is defined as ⟨a, b⟩ + ⟨c, d⟩ = ⟨a + c, b + d⟩. Should not be confused with the ring localization counterpart Localization.add, which maps ⟨a, b⟩ + ⟨c, d⟩ to ⟨d * a + b * c, b * d⟩.

instance AddLocalization.instAddLocalization {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) : Add (AddLocalization S)

Equations

• AddLocalization.instAddLocalization S = { add := AddLocalization.add S }

instance Localization.instMulLocalization {M : Type u_1} [CommMonoid M] (S : Submonoid M) : Mul (Localization S)

Equations

• Localization.instMulLocalization S = { mul := Localization.mul S }

@[irreducible]

def Localization.one {M : Type u_4} [CommMonoid M] (S : Submonoid M) : Localization S

The identity element of a Localization is defined as ⟨1, 1⟩.

Equations

• @Localization.one = Localization.wrapped✝.1

theorem Localization.one_def {M : Type u_4} [CommMonoid M] (S : Submonoid M) : Localization.one S = One.one

def AddLocalization.zero {M : Type u_4} [AddCommMonoid M] (S : AddSubmonoid M) : AddLocalization S

The identity element of an AddLocalization is defined as ⟨0, 0⟩.

Should not be confused with the ring localization counterpart Localization.zero, which is defined as ⟨0, 1⟩.

Equations

• @AddLocalization.zero = Localization.wrapped✝.1

theorem AddLocalization.zero_def {M : Type u_4} [AddCommMonoid M] (S : AddSubmonoid M) : AddLocalization.zero S = Zero.zero

The identity element of an AddLocalization is defined as ⟨0, 0⟩.

Should not be confused with the ring localization counterpart Localization.zero, which is defined as ⟨0, 1⟩.

instance AddLocalization.instZeroLocalization {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) : Zero (AddLocalization S)

Equations

• AddLocalization.instZeroLocalization S = { zero := AddLocalization.zero S }

instance Localization.instOneLocalization {M : Type u_1} [CommMonoid M] (S : Submonoid M) : One (Localization S)

Equations

• Localization.instOneLocalization S = { one := Localization.one S }

theorem Localization.npow_def {M : Type u_4} [CommMonoid M] (S : Submonoid M) : Localization.npow S = Monoid.npow

@[irreducible]

def Localization.npow {M : Type u_4} [CommMonoid M] (S : Submonoid M) : ℕ → Localization S → Localization S

Exponentiation in a Localization is defined as ⟨a, b⟩ ^ n = ⟨a ^ n, b ^ n⟩.

This is a separate irreducible def to ensure the elaborator doesn't waste its time trying to unify some huge recursive definition with itself, but unfolded one step less.

Equations

• @Localization.npow = Localization.wrapped✝.1

def AddLocalization.nsmul {M : Type u_4} [AddCommMonoid M] (S : AddSubmonoid M) : ℕ → AddLocalization S → AddLocalization S

Multiplication with a natural in an AddLocalization is defined as n • ⟨a, b⟩ = ⟨n • a, n • b⟩.

This is a separate irreducible def to ensure the elaborator doesn't waste its time trying to unify some huge recursive definition with itself, but unfolded one step less.

Equations

• @AddLocalization.nsmul = Localization.wrapped✝.1

theorem AddLocalization.nsmul_def {M : Type u_4} [AddCommMonoid M] (S : AddSubmonoid M) : AddLocalization.nsmul S = AddMonoid.nsmul

Multiplication with a natural in an AddLocalization is defined as n • ⟨a, b⟩ = ⟨n • a, n • b⟩.

This is a separate irreducible def to ensure the elaborator doesn't waste its time trying to unify some huge recursive definition with itself, but unfolded one step less.

theorem AddLocalization.addCommMonoid.proof_2 {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) (x : AddLocalization S) : AddLocalization.add S (AddLocalization.zero S) x = x

theorem AddLocalization.addCommMonoid.proof_3 {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) (x : AddLocalization S) : AddLocalization.add S x (AddLocalization.zero S) = x

instance AddLocalization.addCommMonoid {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) : AddCommMonoid (AddLocalization S)

Equations

• AddLocalization.addCommMonoid S = AddCommMonoid.mk (_ : ∀ (x y : AddLocalization S), AddLocalization.add S x y = AddLocalization.add S y x)

theorem AddLocalization.addCommMonoid.proof_6 {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) (x : AddLocalization S) (y : AddLocalization S) : AddLocalization.add S x y = AddLocalization.add S y x

theorem AddLocalization.addCommMonoid.proof_4 {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) (x : AddLocalization S) : AddLocalization.nsmul S 0 x = AddLocalization.zero S

theorem AddLocalization.addCommMonoid.proof_5 {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) (n : ℕ) (x : AddLocalization S) : AddLocalization.nsmul S (Nat.succ n) x = AddLocalization.add S x (AddLocalization.nsmul S n x)

theorem AddLocalization.addCommMonoid.proof_1 {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) (x : AddLocalization S) (y : AddLocalization S) (z : AddLocalization S) : AddLocalization.add S (AddLocalization.add S x y) z = AddLocalization.add S x (AddLocalization.add S y z)

instance Localization.commMonoid {M : Type u_1} [CommMonoid M] (S : Submonoid M) : CommMonoid (Localization S)

Equations

• Localization.commMonoid S = CommMonoid.mk (_ : ∀ (x y : Localization S), Localization.mul S x y = Localization.mul S y x)

def AddLocalization.mk {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} (x : M) (y : { x // x ∈ S }) : AddLocalization 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

• AddLocalization.mk x y = ↑(AddCon.mk' (AddLocalization.r S)) (x, y)

def Localization.mk {M : Type u_1} [CommMonoid M] {S : Submonoid M} (x : M) (y : { x // x ∈ S }) : Localization 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

• Localization.mk x y = ↑(Con.mk' (Localization.r S)) (x, y)

theorem AddLocalization.mk_eq_mk_iff {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {a : M} {c : M} {b : { x // x ∈ S }} {d : { x // x ∈ S }} : AddLocalization.mk a b = AddLocalization.mk c d ↔ ↑(AddLocalization.r S) (a, b) (c, d)

theorem Localization.mk_eq_mk_iff {M : Type u_1} [CommMonoid M] {S : Submonoid M} {a : M} {c : M} {b : { x // x ∈ S }} {d : { x // x ∈ S }} : Localization.mk a b = Localization.mk c d ↔ ↑(Localization.r S) (a, b) (c, d)

theorem AddLocalization.rec.proof_1 {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {a : M} {c : M} {b : { x // x ∈ S }} {d : { x // x ∈ S }} (h : ↑(AddLocalization.r S) (a, b) (c, d)) : AddLocalization.mk a b = AddLocalization.mk c d

theorem AddLocalization.rec.proof_3 {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : AddLocalization S → Sort u_2} (f : (a : M) → (b : { x // x ∈ S }) → p (AddLocalization.mk a b)) (H : ∀ {a c : M} {b d : { x // x ∈ S }} (h : ↑(AddLocalization.r S) (a, b) (c, d)), (_ : AddLocalization.mk a b = AddLocalization.mk c d) ▸ f a b = f c d) (y : M × { x // x ∈ S }) (z : M × { x // x ∈ S }) (h : Setoid.r y z) : (_ : Quot.mk Setoid.r y = Quot.mk Setoid.r z) ▸ (fun y => (_ : AddLocalization.mk y.fst y.snd = AddLocalization.mk y.fst y.snd) ▸ f y.fst y.snd) y = (fun y => (_ : AddLocalization.mk y.fst y.snd = AddLocalization.mk y.fst y.snd) ▸ f y.fst y.snd) z

theorem AddLocalization.rec.proof_2 {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} (y : M × { x // x ∈ S }) : AddLocalization.mk y.fst y.snd = AddLocalization.mk y.fst y.snd

def AddLocalization.rec {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : AddLocalization S → Sort u} (f : (a : M) → (b : { x // x ∈ S }) → p (AddLocalization.mk a b)) (H : ∀ {a c : M} {b d : { x // x ∈ S }} (h : ↑(AddLocalization.r S) (a, b) (c, d)), (_ : AddLocalization.mk a b = AddLocalization.mk 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

• One or more equations did not get rendered due to their size.

def Localization.rec {M : Type u_1} [CommMonoid M] {S : Submonoid M} {p : Localization S → Sort u} (f : (a : M) → (b : { x // x ∈ S }) → p (Localization.mk a b)) (H : ∀ {a c : M} {b d : { x // x ∈ S }} (h : ↑(Localization.r S) (a, b) (c, d)), (_ : Localization.mk a b = Localization.mk 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

• One or more equations did not get rendered due to their size.

theorem AddLocalization.recOnSubsingleton₂.proof_1 {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {r : AddLocalization S → AddLocalization S → Sort u_2} [h : ∀ (a c : M) (b d : { x // x ∈ S }), Subsingleton (r (AddLocalization.mk a b) (AddLocalization.mk c d))] (t : M × { x // x ∈ S }) (b : M × { x // x ∈ S }) : Subsingleton (r (Quotient.mk (AddLocalization.r S).toSetoid t) (Quotient.mk (AddLocalization.r S).toSetoid b))

def AddLocalization.recOnSubsingleton₂ {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {r : AddLocalization S → AddLocalization S → Sort u} [h : ∀ (a c : M) (b d : { x // x ∈ S }), Subsingleton (r (AddLocalization.mk a b) (AddLocalization.mk c d))] (x : AddLocalization S) (y : AddLocalization S) (f : (a c : M) → (b d : { x // x ∈ 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.

def Localization.recOnSubsingleton₂ {M : Type u_1} [CommMonoid M] {S : Submonoid M} {r : Localization S → Localization S → Sort u} [h : ∀ (a c : M) (b d : { x // x ∈ S }), Subsingleton (r (Localization.mk a b) (Localization.mk c d))] (x : Localization S) (y : Localization S) (f : (a c : M) → (b d : { x // x ∈ 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.

theorem AddLocalization.mk_add {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} (a : M) (c : M) (b : { x // x ∈ S }) (d : { x // x ∈ S }) : AddLocalization.mk a b + AddLocalization.mk c d = AddLocalization.mk (a + c) (b + d)

theorem Localization.mk_mul {M : Type u_1} [CommMonoid M] {S : Submonoid M} (a : M) (c : M) (b : { x // x ∈ S }) (d : { x // x ∈ S }) : Localization.mk a b * Localization.mk c d = Localization.mk (a * c) (b * d)

theorem AddLocalization.mk_zero {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} : AddLocalization.mk 0 0 = 0

theorem Localization.mk_one {M : Type u_1} [CommMonoid M] {S : Submonoid M} : Localization.mk 1 1 = 1

theorem AddLocalization.mk_nsmul {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} (n : ℕ) (a : M) (b : { x // x ∈ S }) : n • AddLocalization.mk a b = AddLocalization.mk (n • a) (n • b)

theorem Localization.mk_pow {M : Type u_1} [CommMonoid M] {S : Submonoid M} (n : ℕ) (a : M) (b : { x // x ∈ S }) : Localization.mk a b ^ n = Localization.mk (a ^ n) (b ^ n)

@[simp]

theorem AddLocalization.ndrec_mk {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : AddLocalization S → Sort u} (f : (a : M) → (b : { x // x ∈ S }) → p (AddLocalization.mk a b)) (H : ∀ {a c : M} {b d : { x // x ∈ S }} (h : ↑(AddLocalization.r S) (a, b) (c, d)), (_ : AddLocalization.mk a b = AddLocalization.mk c d) ▸ f a b = f c d) (a : M) (b : { x // x ∈ S }) : AddLocalization.rec f H (AddLocalization.mk a b) = f a b

@[simp]

theorem Localization.ndrec_mk {M : Type u_1} [CommMonoid M] {S : Submonoid M} {p : Localization S → Sort u} (f : (a : M) → (b : { x // x ∈ S }) → p (Localization.mk a b)) (H : ∀ {a c : M} {b d : { x // x ∈ S }} (h : ↑(Localization.r S) (a, b) (c, d)), (_ : Localization.mk a b = Localization.mk c d) ▸ f a b = f c d) (a : M) (b : { x // x ∈ S }) : Localization.rec f H (Localization.mk a b) = f a b

theorem AddLocalization.liftOn.proof_1 {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u_2} (f : M → { x // x ∈ S } → p) (H : ∀ {a c : M} {b d : { x // x ∈ S }}, ↑(AddLocalization.r S) (a, b) (c, d) → f a b = f c d) : ∀ {a c : M} {b d : { x // x ∈ S }} (h : ↑(AddLocalization.r S) (a, b) (c, d)), (_ : AddLocalization.mk a b = AddLocalization.mk c d) ▸ f a b = f c d

def AddLocalization.liftOn {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u} (x : AddLocalization S) (f : M → { x // x ∈ S } → p) (H : ∀ {a c : M} {b d : { x // x ∈ 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

• One or more equations did not get rendered due to their size.

def Localization.liftOn {M : Type u_1} [CommMonoid M] {S : Submonoid M} {p : Sort u} (x : Localization S) (f : M → { x // x ∈ S } → p) (H : ∀ {a c : M} {b d : { x // x ∈ 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

• One or more equations did not get rendered due to their size.

theorem AddLocalization.liftOn_mk {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u} (f : M → { x // x ∈ S } → p) (H : ∀ {a c : M} {b d : { x // x ∈ S }}, ↑(AddLocalization.r S) (a, b) (c, d) → f a b = f c d) (a : M) (b : { x // x ∈ S }) : AddLocalization.liftOn (AddLocalization.mk a b) f H = f a b

theorem Localization.liftOn_mk {M : Type u_1} [CommMonoid M] {S : Submonoid M} {p : Sort u} (f : M → { x // x ∈ S } → p) (H : ∀ {a c : M} {b d : { x // x ∈ S }}, ↑(Localization.r S) (a, b) (c, d) → f a b = f c d) (a : M) (b : { x // x ∈ S }) : Localization.liftOn (Localization.mk a b) f H = f a b

theorem AddLocalization.ind {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : AddLocalization S → Prop} (H : (y : M × { x // x ∈ S }) → p (AddLocalization.mk y.fst y.snd)) (x : AddLocalization S) : p x

theorem Localization.ind {M : Type u_1} [CommMonoid M] {S : Submonoid M} {p : Localization S → Prop} (H : (y : M × { x // x ∈ S }) → p (Localization.mk y.fst y.snd)) (x : Localization S) : p x

theorem AddLocalization.induction_on {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : AddLocalization S → Prop} (x : AddLocalization S) (H : (y : M × { x // x ∈ S }) → p (AddLocalization.mk y.fst y.snd)) : p x

theorem Localization.induction_on {M : Type u_1} [CommMonoid M] {S : Submonoid M} {p : Localization S → Prop} (x : Localization S) (H : (y : M × { x // x ∈ S }) → p (Localization.mk y.fst y.snd)) : p x

theorem AddLocalization.liftOn₂.proof_2 {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u_2} (y : AddLocalization S) (f : M → { x // x ∈ S } → M → { x // x ∈ S } → p) (H : ∀ {a a' : M} {b b' : { x // x ∈ S }} {c c' : M} {d d' : { x // x ∈ 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 c : M} {b d : { x // x ∈ S }}, ↑(AddLocalization.r S) (a, b) (c, d) → (fun a b => AddLocalization.liftOn y (f a b) fun {a_1 c} {b_1 d} hy => H a a b b a_1 c b_1 d (_ : ↑(AddLocalization.r S) (a, b) (a, b)) hy) a b = (fun a b => AddLocalization.liftOn y (f a b) fun {a_1 c} {b_1 d} hy => H a a b b a_1 c b_1 d (_ : ↑(AddLocalization.r S) (a, b) (a, b)) hy) c d

def AddLocalization.liftOn₂ {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u} (x : AddLocalization S) (y : AddLocalization S) (f : M → { x // x ∈ S } → M → { x // x ∈ S } → p) (H : ∀ {a a' : M} {b b' : { x // x ∈ S }} {c c' : M} {d d' : { x // x ∈ 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

• One or more equations did not get rendered due to their size.

abbrev AddLocalization.liftOn₂.match_1 {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} (motive : M × { x // x ∈ S } → Prop) : (x : M × { x // x ∈ S }) → ((fst : M) → (snd : { x // x ∈ S }) → motive (fst, snd)) → motive x

Equations

• AddLocalization.liftOn₂.match_1 motive x h_1 = Prod.casesOn x fun fst snd => h_1 fst snd

theorem AddLocalization.liftOn₂.proof_1 {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u_2} (f : M → { x // x ∈ S } → M → { x // x ∈ S } → p) (H : ∀ {a a' : M} {b b' : { x // x ∈ S }} {c c' : M} {d d' : { x // x ∈ 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) (b : { x // x ∈ S }) : ∀ {a c : M} {b d : { x // x ∈ S }}, ↑(AddLocalization.r S) (a, b) (c, d) → f a b a b = f a b c d

def Localization.liftOn₂ {M : Type u_1} [CommMonoid M] {S : Submonoid M} {p : Sort u} (x : Localization S) (y : Localization S) (f : M → { x // x ∈ S } → M → { x // x ∈ S } → p) (H : ∀ {a a' : M} {b b' : { x // x ∈ S }} {c c' : M} {d d' : { x // x ∈ 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

• One or more equations did not get rendered due to their size.

theorem AddLocalization.liftOn₂_mk {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u_4} (f : M → { x // x ∈ S } → M → { x // x ∈ S } → p) (H : ∀ {a a' : M} {b b' : { x // x ∈ S }} {c c' : M} {d d' : { x // x ∈ 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 : { x // x ∈ S }) (d : { x // x ∈ S }) : AddLocalization.liftOn₂ (AddLocalization.mk a b) (AddLocalization.mk c d) f H = f a b c d

theorem Localization.liftOn₂_mk {M : Type u_1} [CommMonoid M] {S : Submonoid M} {p : Sort u_4} (f : M → { x // x ∈ S } → M → { x // x ∈ S } → p) (H : ∀ {a a' : M} {b b' : { x // x ∈ S }} {c c' : M} {d d' : { x // x ∈ 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 : { x // x ∈ S }) (d : { x // x ∈ S }) : Localization.liftOn₂ (Localization.mk a b) (Localization.mk c d) f H = f a b c d

theorem AddLocalization.induction_on₂ {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : AddLocalization S → AddLocalization S → Prop} (x : AddLocalization S) (y : AddLocalization S) (H : (x y : M × { x // x ∈ S }) → p (AddLocalization.mk x.fst x.snd) (AddLocalization.mk y.fst y.snd)) : p x y

theorem Localization.induction_on₂ {M : Type u_1} [CommMonoid M] {S : Submonoid M} {p : Localization S → Localization S → Prop} (x : Localization S) (y : Localization S) (H : (x y : M × { x // x ∈ S }) → p (Localization.mk x.fst x.snd) (Localization.mk y.fst y.snd)) : p x y

theorem AddLocalization.induction_on₃ {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : AddLocalization S → AddLocalization S → AddLocalization S → Prop} (x : AddLocalization S) (y : AddLocalization S) (z : AddLocalization S) (H : (x y z : M × { x // x ∈ S }) → p (AddLocalization.mk x.fst x.snd) (AddLocalization.mk y.fst y.snd) (AddLocalization.mk z.fst z.snd)) : p x y z

theorem Localization.induction_on₃ {M : Type u_1} [CommMonoid M] {S : Submonoid M} {p : Localization S → Localization S → Localization S → Prop} (x : Localization S) (y : Localization S) (z : Localization S) (H : (x y z : M × { x // x ∈ S }) → p (Localization.mk x.fst x.snd) (Localization.mk y.fst y.snd) (Localization.mk z.fst z.snd)) : p x y z

theorem AddLocalization.zero_rel {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} (y : { x // x ∈ S }) : ↑(AddLocalization.r S) 0 (↑y, y)

theorem Localization.one_rel {M : Type u_1} [CommMonoid M] {S : Submonoid M} (y : { x // x ∈ S }) : ↑(Localization.r S) 1 (↑y, y)

theorem AddLocalization.r_of_eq {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {x : M × { x // x ∈ S }} {y : M × { x // x ∈ S }} (h : ↑y.snd + x.fst = ↑x.snd + y.fst) : ↑(AddLocalization.r S) x y

theorem Localization.r_of_eq {M : Type u_1} [CommMonoid M] {S : Submonoid M} {x : M × { x // x ∈ S }} {y : M × { x // x ∈ S }} (h : ↑y.snd * x.fst = ↑x.snd * y.fst) : ↑(Localization.r S) x y

theorem AddLocalization.mk_self {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} (a : { x // x ∈ S }) : AddLocalization.mk (↑a) a = 0

theorem Localization.mk_self {M : Type u_1} [CommMonoid M] {S : Submonoid M} (a : { x // x ∈ S }) : Localization.mk (↑a) a = 1

theorem Localization.smul_def {M : Type u_7} [CommMonoid M] {S : Submonoid M} {R : Type u_8} [SMul R M] [IsScalarTower R M M] (c : R) (z : Localization S) : Localization.smul c z = Localization.liftOn z (fun a b => Localization.mk (c • a) b) (_ : ∀ {a a' : M} {b b' : { x // x ∈ S }}, ↑(Localization.r S) (a, b) (a', b') → Localization.mk (c • a) b = Localization.mk (c • a') b')

@[irreducible]

def Localization.smul {M : Type u_7} [CommMonoid M] {S : Submonoid M} {R : Type u_8} [SMul R M] [IsScalarTower R M M] (c : R) (z : Localization S) : Localization S

Scalar multiplication in a monoid localization is defined as c • ⟨a, b⟩ = ⟨c • a, b⟩.

Equations

• @Localization.smul = Localization.wrapped✝.1

instance Localization.instSMulLocalization {M : Type u_1} [CommMonoid M] {S : Submonoid M} {R : Type u_4} [SMul R M] [IsScalarTower R M M] : SMul R (Localization S)

Equations

• Localization.instSMulLocalization = { smul := Localization.smul }

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 : { x // x ∈ S }) : c • Localization.mk a b = Localization.mk (c • a) b

instance Localization.instSMulCommClassLocalizationInstSMulLocalizationInstSMulLocalization {M : Type u_1} [CommMonoid M] {S : Submonoid M} {R₁ : Type u_5} {R₂ : Type u_6} [SMul R₁ M] [SMul R₂ M] [IsScalarTower R₁ M M] [IsScalarTower R₂ M M] [SMulCommClass R₁ R₂ M] : SMulCommClass R₁ R₂ (Localization S)

Equations

• @Localization.instSMulCommClassLocalizationInstSMulLocalizationInstSMulLocalization = @Localization.instSMulCommClassLocalizationInstSMulLocalizationInstSMulLocalization.proof_1

instance Localization.instIsScalarTowerLocalizationInstSMulLocalizationInstSMulLocalization {M : Type u_1} [CommMonoid M] {S : Submonoid M} {R₁ : Type u_5} {R₂ : Type u_6} [SMul R₁ M] [SMul R₂ M] [IsScalarTower R₁ M M] [IsScalarTower R₂ M M] [SMul R₁ R₂] [IsScalarTower R₁ R₂ M] : IsScalarTower R₁ R₂ (Localization S)

Equations

• @Localization.instIsScalarTowerLocalizationInstSMulLocalizationInstSMulLocalization = @Localization.instIsScalarTowerLocalizationInstSMulLocalizationInstSMulLocalization.proof_1

instance Localization.smulCommClass_right {M : Type u_1} [CommMonoid M] {S : Submonoid M} {R : Type u_7} [SMul R M] [IsScalarTower R M M] : SMulCommClass R (Localization S) (Localization S)

Equations

• @Localization.smulCommClass_right = @Localization.smulCommClass_right.proof_1

instance Localization.isScalarTower_right {M : Type u_1} [CommMonoid M] {S : Submonoid M} {R : Type u_7} [SMul R M] [IsScalarTower R M M] : IsScalarTower R (Localization S) (Localization S)

Equations

• @Localization.isScalarTower_right = @Localization.isScalarTower_right.proof_1

instance Localization.instIsCentralScalarLocalizationInstSMulLocalizationMulOpposite {M : Type u_1} [CommMonoid M] {S : Submonoid M} {R : Type u_4} [SMul R M] [SMul Rᵐᵒᵖ M] [IsScalarTower R M M] [IsScalarTower Rᵐᵒᵖ M M] [IsCentralScalar R M] : IsCentralScalar R (Localization S)

Equations

• @Localization.instIsCentralScalarLocalizationInstSMulLocalizationMulOpposite = @Localization.instIsCentralScalarLocalizationInstSMulLocalizationMulOpposite.proof_1

instance Localization.instMulActionLocalization {M : Type u_1} [CommMonoid M] {S : Submonoid M} {R : Type u_4} [Monoid R] [MulAction R M] [IsScalarTower R M M] : MulAction R (Localization S)

Equations

• Localization.instMulActionLocalization = MulAction.mk (_ : ∀ (x : Localization S), 1 • x = x) (_ : ∀ (s₁ s₂ : R) (x : Localization S), (s₁ * s₂) • x = s₁ • s₂ • x)

instance Localization.instMulDistribMulActionLocalizationToMonoidCommMonoid {M : Type u_1} [CommMonoid M] {S : Submonoid M} {R : Type u_4} [Monoid R] [MulDistribMulAction R M] [IsScalarTower R M M] : MulDistribMulAction R (Localization S)

Equations

• Localization.instMulDistribMulActionLocalizationToMonoidCommMonoid = MulDistribMulAction.mk (_ : ∀ (s : R) (x y : Localization S), s • (x * y) = s • x * s • y) (_ : ∀ (s : R), s • 1 = 1)

def AddMonoidHom.toLocalizationMap {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : M →+ N) (H1 : ∀ (y : { x // x ∈ S }), IsAddUnit (↑f ↑y)) (H2 : ∀ (z : N), ∃ x, z + ↑f ↑x.snd = ↑f x.fst) (H3 : ∀ (x y : M), ↑f x = ↑f y ↔ ∃ c, ↑c + x = ↑c + y) : AddSubmonoid.LocalizationMap S N

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

Equations

• One or more equations did not get rendered due to their size.

theorem AddMonoidHom.toLocalizationMap.proof_1 {M : Type u_2} [AddCommMonoid M] {N : Type u_1} [AddCommMonoid N] (f : M →+ N) (x : M) (y : M) : ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y

def MonoidHom.toLocalizationMap {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : M →* N) (H1 : ∀ (y : { x // x ∈ S }), IsUnit (↑f ↑y)) (H2 : ∀ (z : N), ∃ x, z * ↑f ↑x.snd = ↑f x.fst) (H3 : ∀ (x y : M), ↑f x = ↑f y ↔ ∃ c, ↑c * x = ↑c * y) : Submonoid.LocalizationMap S N

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

Equations

• One or more equations did not get rendered due to their size.

abbrev AddSubmonoid.LocalizationMap.toMap {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) : M →+ N

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

Equations

• AddSubmonoid.LocalizationMap.toMap f = f.toAddMonoidHom

@[inline, reducible]

abbrev Submonoid.LocalizationMap.toMap {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) : M →* N

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

Equations

• Submonoid.LocalizationMap.toMap f = f.toMonoidHom

theorem AddSubmonoid.LocalizationMap.ext {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : AddSubmonoid.LocalizationMap S N} {g : AddSubmonoid.LocalizationMap S N} (h : ∀ (x : M), ↑(AddSubmonoid.LocalizationMap.toMap f) x = ↑(AddSubmonoid.LocalizationMap.toMap g) x) : f = g

theorem Submonoid.LocalizationMap.ext {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : Submonoid.LocalizationMap S N} {g : Submonoid.LocalizationMap S N} (h : ∀ (x : M), ↑(Submonoid.LocalizationMap.toMap f) x = ↑(Submonoid.LocalizationMap.toMap g) x) : f = g

theorem AddSubmonoid.LocalizationMap.ext_iff {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : AddSubmonoid.LocalizationMap S N} {g : AddSubmonoid.LocalizationMap S N} : f = g ↔ ∀ (x : M), ↑(AddSubmonoid.LocalizationMap.toMap f) x = ↑(AddSubmonoid.LocalizationMap.toMap g) x

theorem Submonoid.LocalizationMap.ext_iff {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : Submonoid.LocalizationMap S N} {g : Submonoid.LocalizationMap S N} : f = g ↔ ∀ (x : M), ↑(Submonoid.LocalizationMap.toMap f) x = ↑(Submonoid.LocalizationMap.toMap g) x

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.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.map_addUnits {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) (y : { x // x ∈ S }) : IsAddUnit (↑(AddSubmonoid.LocalizationMap.toMap f) ↑y)

theorem Submonoid.LocalizationMap.map_units {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) (y : { x // x ∈ S }) : IsUnit (↑(Submonoid.LocalizationMap.toMap f) ↑y)

theorem AddSubmonoid.LocalizationMap.surj {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) (z : N) : ∃ x, z + ↑(AddSubmonoid.LocalizationMap.toMap f) ↑x.snd = ↑(AddSubmonoid.LocalizationMap.toMap f) x.fst

theorem Submonoid.LocalizationMap.surj {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) (z : N) : ∃ x, z * ↑(Submonoid.LocalizationMap.toMap f) ↑x.snd = ↑(Submonoid.LocalizationMap.toMap f) x.fst

theorem AddSubmonoid.LocalizationMap.eq_iff_exists {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) {x : M} {y : M} : ↑(AddSubmonoid.LocalizationMap.toMap f) x = ↑(AddSubmonoid.LocalizationMap.toMap f) y ↔ ∃ c, ↑c + x = ↑c + y

theorem Submonoid.LocalizationMap.eq_iff_exists {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) {x : M} {y : M} : ↑(Submonoid.LocalizationMap.toMap f) x = ↑(Submonoid.LocalizationMap.toMap f) y ↔ ∃ c, ↑c * x = ↑c * y

noncomputable def AddSubmonoid.LocalizationMap.sec {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) (z : N) : M × { x // x ∈ 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

• AddSubmonoid.LocalizationMap.sec f z = Classical.choose (_ : ∃ x, z + ↑(AddSubmonoid.LocalizationMap.toMap f) ↑x.snd = ↑(AddSubmonoid.LocalizationMap.toMap f) x.fst)

noncomputable def Submonoid.LocalizationMap.sec {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) (z : N) : M × { x // x ∈ 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

• Submonoid.LocalizationMap.sec f z = Classical.choose (_ : ∃ x, z * ↑(Submonoid.LocalizationMap.toMap f) ↑x.snd = ↑(Submonoid.LocalizationMap.toMap f) x.fst)

theorem AddSubmonoid.LocalizationMap.sec_spec {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : AddSubmonoid.LocalizationMap S N} (z : N) : z + ↑(AddSubmonoid.LocalizationMap.toMap f) ↑(AddSubmonoid.LocalizationMap.sec f z).snd = ↑(AddSubmonoid.LocalizationMap.toMap f) (AddSubmonoid.LocalizationMap.sec f z).fst

theorem Submonoid.LocalizationMap.sec_spec {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : Submonoid.LocalizationMap S N} (z : N) : z * ↑(Submonoid.LocalizationMap.toMap f) ↑(Submonoid.LocalizationMap.sec f z).snd = ↑(Submonoid.LocalizationMap.toMap f) (Submonoid.LocalizationMap.sec f z).fst

theorem AddSubmonoid.LocalizationMap.sec_spec' {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : AddSubmonoid.LocalizationMap S N} (z : N) : ↑(AddSubmonoid.LocalizationMap.toMap f) (AddSubmonoid.LocalizationMap.sec f z).fst = ↑(AddSubmonoid.LocalizationMap.toMap f) ↑(AddSubmonoid.LocalizationMap.sec f z).snd + z

theorem Submonoid.LocalizationMap.sec_spec' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : Submonoid.LocalizationMap S N} (z : N) : ↑(Submonoid.LocalizationMap.toMap f) (Submonoid.LocalizationMap.sec f z).fst = ↑(Submonoid.LocalizationMap.toMap f) ↑(Submonoid.LocalizationMap.sec f z).snd * 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 : { x // x ∈ S }), IsAddUnit (↑f ↑y)) (y : { x // x ∈ S }) (w : N) (z : N) : w + ↑(-↑(IsAddUnit.liftRight (AddMonoidHom.restrict f 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_left {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : M →* N} (h : ∀ (y : { x // x ∈ S }), IsUnit (↑f ↑y)) (y : { x // x ∈ S }) (w : N) (z : N) : w * ↑(↑(IsUnit.liftRight (MonoidHom.restrict f 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_right {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : M →+ N} (h : ∀ (y : { x // x ∈ S }), IsAddUnit (↑f ↑y)) (y : { x // x ∈ S }) (w : N) (z : N) : z = w + ↑(-↑(IsAddUnit.liftRight (AddMonoidHom.restrict f 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.

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 : { x // x ∈ S }), IsUnit (↑f ↑y)) (y : { x // x ∈ S }) (w : N) (z : N) : z = w * ↑(↑(IsUnit.liftRight (MonoidHom.restrict f 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.

@[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 : { x // x ∈ S }), IsAddUnit (↑f ↑y)) {x₁ : M} {x₂ : M} {y₁ : { x // x ∈ S }} {y₂ : { x // x ∈ S }} : ↑f x₁ + ↑(-↑(IsAddUnit.liftRight (AddMonoidHom.restrict f S) h) y₁) = ↑f x₂ + ↑(-↑(IsAddUnit.liftRight (AddMonoidHom.restrict f 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₁).

@[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 : { x // x ∈ S }), IsUnit (↑f ↑y)) {x₁ : M} {x₂ : M} {y₁ : { x // x ∈ S }} {y₂ : { x // x ∈ S }} : ↑f x₁ * ↑(↑(IsUnit.liftRight (MonoidHom.restrict f S) h) y₁)⁻¹ = ↑f x₂ * ↑(↑(IsUnit.liftRight (MonoidHom.restrict f 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₁).

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 : { x // x ∈ S }), IsAddUnit (↑f ↑y)) {y : { x // x ∈ S }} {z : { x // x ∈ S }} (h : -↑(IsAddUnit.liftRight (AddMonoidHom.restrict f S) hf) y = -↑(IsAddUnit.liftRight (AddMonoidHom.restrict f 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_inj {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : M →* N} (hf : ∀ (y : { x // x ∈ S }), IsUnit (↑f ↑y)) {y : { x // x ∈ S }} {z : { x // x ∈ S }} (h : (↑(IsUnit.liftRight (MonoidHom.restrict f S) hf) y)⁻¹ = (↑(IsUnit.liftRight (MonoidHom.restrict f 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_unique {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : M →+ N} (h : ∀ (y : { x // x ∈ S }), IsAddUnit (↑f ↑y)) {y : { x // x ∈ S }} {z : N} (H : ↑f ↑y + z = 0) : ↑(-↑(IsAddUnit.liftRight (AddMonoidHom.restrict f 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.inv_unique {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : M →* N} (h : ∀ (y : { x // x ∈ S }), IsUnit (↑f ↑y)) {y : { x // x ∈ S }} {z : N} (H : ↑f ↑y * z = 1) : ↑(↑(IsUnit.liftRight (MonoidHom.restrict f 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.map_right_cancel {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) {x : M} {y : M} {c : { x // x ∈ S }} (h : ↑(AddSubmonoid.LocalizationMap.toMap f) (↑c + x) = ↑(AddSubmonoid.LocalizationMap.toMap f) (↑c + y)) : ↑(AddSubmonoid.LocalizationMap.toMap f) x = ↑(AddSubmonoid.LocalizationMap.toMap f) y

theorem Submonoid.LocalizationMap.map_right_cancel {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) {x : M} {y : M} {c : { x // x ∈ S }} (h : ↑(Submonoid.LocalizationMap.toMap f) (↑c * x) = ↑(Submonoid.LocalizationMap.toMap f) (↑c * y)) : ↑(Submonoid.LocalizationMap.toMap f) x = ↑(Submonoid.LocalizationMap.toMap f) y

theorem AddSubmonoid.LocalizationMap.map_left_cancel {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) {x : M} {y : M} {c : { x // x ∈ S }} (h : ↑(AddSubmonoid.LocalizationMap.toMap f) (x + ↑c) = ↑(AddSubmonoid.LocalizationMap.toMap f) (y + ↑c)) : ↑(AddSubmonoid.LocalizationMap.toMap f) x = ↑(AddSubmonoid.LocalizationMap.toMap f) y

theorem Submonoid.LocalizationMap.map_left_cancel {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) {x : M} {y : M} {c : { x // x ∈ S }} (h : ↑(Submonoid.LocalizationMap.toMap f) (x * ↑c) = ↑(Submonoid.LocalizationMap.toMap f) (y * ↑c)) : ↑(Submonoid.LocalizationMap.toMap f) x = ↑(Submonoid.LocalizationMap.toMap f) y

theorem AddSubmonoid.LocalizationMap.mk'.proof_1 {M : Type u_1} [AddCommMonoid M] : AddSubmonoidClass (AddSubmonoid M) M

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

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

Equations

• One or more equations did not get rendered due to their size.

noncomputable def Submonoid.LocalizationMap.mk' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) (x : M) (y : { x // x ∈ S }) : N

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

Equations

• One or more equations did not get rendered due to their size.

theorem AddSubmonoid.LocalizationMap.mk'_add {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) (x₁ : M) (x₂ : M) (y₁ : { x // x ∈ S }) (y₂ : { x // x ∈ S }) : AddSubmonoid.LocalizationMap.mk' f (x₁ + x₂) (y₁ + y₂) = AddSubmonoid.LocalizationMap.mk' f x₁ y₁ + AddSubmonoid.LocalizationMap.mk' f x₂ y₂

theorem Submonoid.LocalizationMap.mk'_mul {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) (x₁ : M) (x₂ : M) (y₁ : { x // x ∈ S }) (y₂ : { x // x ∈ S }) : Submonoid.LocalizationMap.mk' f (x₁ * x₂) (y₁ * y₂) = Submonoid.LocalizationMap.mk' f x₁ y₁ * Submonoid.LocalizationMap.mk' f x₂ y₂

theorem AddSubmonoid.LocalizationMap.mk'_zero {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) (x : M) : AddSubmonoid.LocalizationMap.mk' f x 0 = ↑(AddSubmonoid.LocalizationMap.toMap f) x

theorem Submonoid.LocalizationMap.mk'_one {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) (x : M) : Submonoid.LocalizationMap.mk' f x 1 = ↑(Submonoid.LocalizationMap.toMap f) x

@[simp]

theorem AddSubmonoid.LocalizationMap.mk'_sec {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) (z : N) : AddSubmonoid.LocalizationMap.mk' f (AddSubmonoid.LocalizationMap.sec f z).fst (AddSubmonoid.LocalizationMap.sec f z).snd = 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 Submonoid.LocalizationMap.mk'_sec {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) (z : N) : Submonoid.LocalizationMap.mk' f (Submonoid.LocalizationMap.sec f z).fst (Submonoid.LocalizationMap.sec f z).snd = 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 AddSubmonoid.LocalizationMap.mk'_surjective {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) (z : N) : ∃ x y, AddSubmonoid.LocalizationMap.mk' f x y = z

theorem Submonoid.LocalizationMap.mk'_surjective {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) (z : N) : ∃ x y, Submonoid.LocalizationMap.mk' f x y = z

theorem AddSubmonoid.LocalizationMap.mk'_spec {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) (x : M) (y : { x // x ∈ S }) : AddSubmonoid.LocalizationMap.mk' f x y + ↑(AddSubmonoid.LocalizationMap.toMap f) ↑y = ↑(AddSubmonoid.LocalizationMap.toMap f) x

theorem Submonoid.LocalizationMap.mk'_spec {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) (x : M) (y : { x // x ∈ S }) : Submonoid.LocalizationMap.mk' f x y * ↑(Submonoid.LocalizationMap.toMap f) ↑y = ↑(Submonoid.LocalizationMap.toMap f) x

theorem AddSubmonoid.LocalizationMap.mk'_spec' {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) (x : M) (y : { x // x ∈ S }) : ↑(AddSubmonoid.LocalizationMap.toMap f) ↑y + AddSubmonoid.LocalizationMap.mk' f x y = ↑(AddSubmonoid.LocalizationMap.toMap f) x

theorem Submonoid.LocalizationMap.mk'_spec' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) (x : M) (y : { x // x ∈ S }) : ↑(Submonoid.LocalizationMap.toMap f) ↑y * Submonoid.LocalizationMap.mk' f x y = ↑(Submonoid.LocalizationMap.toMap f) 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 : AddSubmonoid.LocalizationMap S N) {x : M} {y : { x // x ∈ S }} {z : N} : z = AddSubmonoid.LocalizationMap.mk' f x y ↔ z + ↑(AddSubmonoid.LocalizationMap.toMap f) ↑y = ↑(AddSubmonoid.LocalizationMap.toMap f) 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 : Submonoid.LocalizationMap S N) {x : M} {y : { x // x ∈ S }} {z : N} : z = Submonoid.LocalizationMap.mk' f x y ↔ z * ↑(Submonoid.LocalizationMap.toMap f) ↑y = ↑(Submonoid.LocalizationMap.toMap f) x

theorem AddSubmonoid.LocalizationMap.mk'_eq_iff_eq_add {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) {x : M} {y : { x // x ∈ S }} {z : N} : AddSubmonoid.LocalizationMap.mk' f x y = z ↔ ↑(AddSubmonoid.LocalizationMap.toMap f) x = z + ↑(AddSubmonoid.LocalizationMap.toMap f) ↑y

theorem Submonoid.LocalizationMap.mk'_eq_iff_eq_mul {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) {x : M} {y : { x // x ∈ S }} {z : N} : Submonoid.LocalizationMap.mk' f x y = z ↔ ↑(Submonoid.LocalizationMap.toMap f) x = z * ↑(Submonoid.LocalizationMap.toMap f) ↑y

theorem AddSubmonoid.LocalizationMap.mk'_eq_iff_eq {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) {x₁ : M} {x₂ : M} {y₁ : { x // x ∈ S }} {y₂ : { x // x ∈ S }} : AddSubmonoid.LocalizationMap.mk' f x₁ y₁ = AddSubmonoid.LocalizationMap.mk' f x₂ y₂ ↔ ↑(AddSubmonoid.LocalizationMap.toMap f) (↑y₂ + x₁) = ↑(AddSubmonoid.LocalizationMap.toMap f) (↑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 : Submonoid.LocalizationMap S N) {x₁ : M} {x₂ : M} {y₁ : { x // x ∈ S }} {y₂ : { x // x ∈ S }} : Submonoid.LocalizationMap.mk' f x₁ y₁ = Submonoid.LocalizationMap.mk' f x₂ y₂ ↔ ↑(Submonoid.LocalizationMap.toMap f) (↑y₂ * x₁) = ↑(Submonoid.LocalizationMap.toMap f) (↑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 : AddSubmonoid.LocalizationMap S N) {x₁ : M} {x₂ : M} {y₁ : { x // x ∈ S }} {y₂ : { x // x ∈ S }} : AddSubmonoid.LocalizationMap.mk' f x₁ y₁ = AddSubmonoid.LocalizationMap.mk' f x₂ y₂ ↔ ↑(AddSubmonoid.LocalizationMap.toMap f) (x₁ + ↑y₂) = ↑(AddSubmonoid.LocalizationMap.toMap f) (x₂ + ↑y₁)

theorem Submonoid.LocalizationMap.mk'_eq_iff_eq' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) {x₁ : M} {x₂ : M} {y₁ : { x // x ∈ S }} {y₂ : { x // x ∈ S }} : Submonoid.LocalizationMap.mk' f x₁ y₁ = Submonoid.LocalizationMap.mk' f x₂ y₂ ↔ ↑(Submonoid.LocalizationMap.toMap f) (x₁ * ↑y₂) = ↑(Submonoid.LocalizationMap.toMap f) (x₂ * ↑y₁)

theorem AddSubmonoid.LocalizationMap.eq {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) {a₁ : M} {b₁ : M} {a₂ : { x // x ∈ S }} {b₂ : { x // x ∈ S }} : AddSubmonoid.LocalizationMap.mk' f a₁ a₂ = AddSubmonoid.LocalizationMap.mk' f b₁ b₂ ↔ ∃ c, ↑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 : Submonoid.LocalizationMap S N) {a₁ : M} {b₁ : M} {a₂ : { x // x ∈ S }} {b₂ : { x // x ∈ S }} : Submonoid.LocalizationMap.mk' f a₁ a₂ = Submonoid.LocalizationMap.mk' f b₁ b₂ ↔ ∃ c, ↑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 : AddSubmonoid.LocalizationMap S N) {a₁ : M} {b₁ : M} {a₂ : { x // x ∈ S }} {b₂ : { x // x ∈ S }} : AddSubmonoid.LocalizationMap.mk' f a₁ a₂ = AddSubmonoid.LocalizationMap.mk' f b₁ b₂ ↔ ↑(AddLocalization.r S) (a₁, a₂) (b₁, b₂)

theorem Submonoid.LocalizationMap.eq' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) {a₁ : M} {b₁ : M} {a₂ : { x // x ∈ S }} {b₂ : { x // x ∈ S }} : Submonoid.LocalizationMap.mk' f a₁ a₂ = Submonoid.LocalizationMap.mk' f b₁ b₂ ↔ ↑(Localization.r S) (a₁, a₂) (b₁, b₂)

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 : AddSubmonoid.LocalizationMap S N) (g : AddSubmonoid.LocalizationMap S P) {x : M} {y : M} : ↑(AddSubmonoid.LocalizationMap.toMap f) x = ↑(AddSubmonoid.LocalizationMap.toMap f) y ↔ ↑(AddSubmonoid.LocalizationMap.toMap g) x = ↑(AddSubmonoid.LocalizationMap.toMap g) y

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 : Submonoid.LocalizationMap S N) (g : Submonoid.LocalizationMap S P) {x : M} {y : M} : ↑(Submonoid.LocalizationMap.toMap f) x = ↑(Submonoid.LocalizationMap.toMap f) y ↔ ↑(Submonoid.LocalizationMap.toMap g) x = ↑(Submonoid.LocalizationMap.toMap g) 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 : AddSubmonoid.LocalizationMap S N) (g : AddSubmonoid.LocalizationMap S P) {x₁ : M} {x₂ : M} {y₁ : { x // x ∈ S }} {y₂ : { x // x ∈ S }} : AddSubmonoid.LocalizationMap.mk' f x₁ y₁ = AddSubmonoid.LocalizationMap.mk' f x₂ y₂ ↔ AddSubmonoid.LocalizationMap.mk' g x₁ y₁ = AddSubmonoid.LocalizationMap.mk' g x₂ 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 : Submonoid.LocalizationMap S N) (g : Submonoid.LocalizationMap S P) {x₁ : M} {x₂ : M} {y₁ : { x // x ∈ S }} {y₂ : { x // x ∈ S }} : Submonoid.LocalizationMap.mk' f x₁ y₁ = Submonoid.LocalizationMap.mk' f x₂ y₂ ↔ Submonoid.LocalizationMap.mk' g x₁ y₁ = Submonoid.LocalizationMap.mk' g x₂ y₂

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

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.exists_of_sec_mk' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) (x : M) (y : { x // x ∈ S }) : ∃ c, ↑c * (↑(Submonoid.LocalizationMap.sec f (Submonoid.LocalizationMap.mk' f x y)).snd * x) = ↑c * (↑y * (Submonoid.LocalizationMap.sec f (Submonoid.LocalizationMap.mk' f x y)).fst)

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.mk'_eq_of_eq {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) {a₁ : M} {b₁ : M} {a₂ : { x // x ∈ S }} {b₂ : { x // x ∈ S }} (H : ↑a₂ + b₁ = ↑b₂ + a₁) : AddSubmonoid.LocalizationMap.mk' f a₁ a₂ = AddSubmonoid.LocalizationMap.mk' f 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 : Submonoid.LocalizationMap S N) {a₁ : M} {b₁ : M} {a₂ : { x // x ∈ S }} {b₂ : { x // x ∈ S }} (H : ↑a₂ * b₁ = ↑b₂ * a₁) : Submonoid.LocalizationMap.mk' f a₁ a₂ = Submonoid.LocalizationMap.mk' f 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 : AddSubmonoid.LocalizationMap S N) {a₁ : M} {b₁ : M} {a₂ : { x // x ∈ S }} {b₂ : { x // x ∈ S }} (H : b₁ + ↑a₂ = a₁ + ↑b₂) : AddSubmonoid.LocalizationMap.mk' f a₁ a₂ = AddSubmonoid.LocalizationMap.mk' f 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 : Submonoid.LocalizationMap S N) {a₁ : M} {b₁ : M} {a₂ : { x // x ∈ S }} {b₂ : { x // x ∈ S }} (H : b₁ * ↑a₂ = a₁ * ↑b₂) : Submonoid.LocalizationMap.mk' f a₁ a₂ = Submonoid.LocalizationMap.mk' f b₁ b₂

@[simp]

theorem AddSubmonoid.LocalizationMap.mk'_self' {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) (y : { x // x ∈ S }) : AddSubmonoid.LocalizationMap.mk' f (↑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 : Submonoid.LocalizationMap S N) (y : { x // x ∈ S }) : Submonoid.LocalizationMap.mk' f (↑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 : AddSubmonoid.LocalizationMap S N) (x : M) (H : x ∈ S) : AddSubmonoid.LocalizationMap.mk' f x { val := x, property := H } = 0

@[simp]

theorem Submonoid.LocalizationMap.mk'_self {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) (x : M) (H : x ∈ S) : Submonoid.LocalizationMap.mk' f x { val := x, property := H } = 1

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 : AddSubmonoid.LocalizationMap S N) (x₁ : M) (x₂ : M) (y : { x // x ∈ S }) : ↑(AddSubmonoid.LocalizationMap.toMap f) x₁ + AddSubmonoid.LocalizationMap.mk' f x₂ y = AddSubmonoid.LocalizationMap.mk' f (x₁ + x₂) y

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 : Submonoid.LocalizationMap S N) (x₁ : M) (x₂ : M) (y : { x // x ∈ S }) : ↑(Submonoid.LocalizationMap.toMap f) x₁ * Submonoid.LocalizationMap.mk' f x₂ y = Submonoid.LocalizationMap.mk' f (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 : AddSubmonoid.LocalizationMap S N) (x₁ : M) (x₂ : M) (y : { x // x ∈ S }) : AddSubmonoid.LocalizationMap.mk' f x₂ y + ↑(AddSubmonoid.LocalizationMap.toMap f) x₁ = AddSubmonoid.LocalizationMap.mk' f (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 : Submonoid.LocalizationMap S N) (x₁ : M) (x₂ : M) (y : { x // x ∈ S }) : Submonoid.LocalizationMap.mk' f x₂ y * ↑(Submonoid.LocalizationMap.toMap f) x₁ = Submonoid.LocalizationMap.mk' f (x₁ * 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 : AddSubmonoid.LocalizationMap S N) (x : M) (y : { x // x ∈ S }) : ↑(AddSubmonoid.LocalizationMap.toMap f) x + AddSubmonoid.LocalizationMap.mk' f 0 y = AddSubmonoid.LocalizationMap.mk' f 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 : Submonoid.LocalizationMap S N) (x : M) (y : { x // x ∈ S }) : ↑(Submonoid.LocalizationMap.toMap f) x * Submonoid.LocalizationMap.mk' f 1 y = Submonoid.LocalizationMap.mk' f x y

@[simp]

theorem AddSubmonoid.LocalizationMap.mk'_add_cancel_right {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) (x : M) (y : { x // x ∈ S }) : AddSubmonoid.LocalizationMap.mk' f (x + ↑y) y = ↑(AddSubmonoid.LocalizationMap.toMap f) x

@[simp]

theorem Submonoid.LocalizationMap.mk'_mul_cancel_right {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) (x : M) (y : { x // x ∈ S }) : Submonoid.LocalizationMap.mk' f (x * ↑y) y = ↑(Submonoid.LocalizationMap.toMap f) x

theorem AddSubmonoid.LocalizationMap.mk'_add_cancel_left {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) (x : M) (y : { x // x ∈ S }) : AddSubmonoid.LocalizationMap.mk' f (↑y + x) y = ↑(AddSubmonoid.LocalizationMap.toMap f) x

theorem Submonoid.LocalizationMap.mk'_mul_cancel_left {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) (x : M) (y : { x // x ∈ S }) : Submonoid.LocalizationMap.mk' f (↑y * x) y = ↑(Submonoid.LocalizationMap.toMap f) x

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 : AddSubmonoid.LocalizationMap S N) (j : N →+ P) (y : { x // x ∈ S }) : IsAddUnit (↑(AddMonoidHom.comp j (AddSubmonoid.LocalizationMap.toMap f)) ↑y)

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 : Submonoid.LocalizationMap S N) (j : N →* P) (y : { x // x ∈ S }) : IsUnit (↑(MonoidHom.comp j (Submonoid.LocalizationMap.toMap f)) ↑y)

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 : AddSubmonoid.LocalizationMap S N) {g : M →+ P} (hg : ∀ (y : { x // x ∈ S }), IsAddUnit (↑g ↑y)) {x : M} {y : M} (h : ↑(AddSubmonoid.LocalizationMap.toMap f) x = ↑(AddSubmonoid.LocalizationMap.toMap f) 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.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 : Submonoid.LocalizationMap S N) {g : M →* P} (hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)) {x : M} {y : M} (h : ↑(Submonoid.LocalizationMap.toMap f) x = ↑(Submonoid.LocalizationMap.toMap f) 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.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 : AddSubmonoid.LocalizationMap S N) {g : M →+ P} {T : AddSubmonoid P} {Q : Type u_4} [AddCommMonoid Q] (hg : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T) (k : AddSubmonoid.LocalizationMap T Q) {x : M} {y : M} (h : ↑(AddSubmonoid.LocalizationMap.toMap f) x = ↑(AddSubmonoid.LocalizationMap.toMap f) y) : ↑(AddSubmonoid.LocalizationMap.toMap k) (↑g x) = ↑(AddSubmonoid.LocalizationMap.toMap k) (↑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).

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 : Submonoid.LocalizationMap S N) {g : M →* P} {T : Submonoid P} {Q : Type u_4} [CommMonoid Q] (hg : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T) (k : Submonoid.LocalizationMap T Q) {x : M} {y : M} (h : ↑(Submonoid.LocalizationMap.toMap f) x = ↑(Submonoid.LocalizationMap.toMap f) y) : ↑(Submonoid.LocalizationMap.toMap k) (↑g x) = ↑(Submonoid.LocalizationMap.toMap k) (↑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.lift.proof_2 {M : Type u_2} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_3} [AddCommMonoid N] {P : Type u_1} [AddCommMonoid P] (f : AddSubmonoid.LocalizationMap S N) {g : M →+ P} (hg : ∀ (y : { x // x ∈ S }), IsAddUnit (↑g ↑y)) : (fun z => ↑g (AddSubmonoid.LocalizationMap.sec f z).fst + ↑(-↑(IsAddUnit.liftRight (AddMonoidHom.restrict g S) hg) (AddSubmonoid.LocalizationMap.sec f z).snd)) 0 = 0

theorem AddSubmonoid.LocalizationMap.lift.proof_1 {M : Type u_1} [AddCommMonoid M] : AddSubmonoidClass (AddSubmonoid M) M

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 : AddSubmonoid.LocalizationMap S N) {g : M →+ P} (hg : ∀ (y : { x // x ∈ 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

• One or more equations did not get rendered due to their size.

theorem AddSubmonoid.LocalizationMap.lift.proof_3 {M : Type u_3} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_1} [AddCommMonoid P] (f : AddSubmonoid.LocalizationMap S N) {g : M →+ P} (hg : ∀ (y : { x // x ∈ S }), IsAddUnit (↑g ↑y)) (x : N) (y : N) : ZeroHom.toFun { toFun := fun z => ↑g (AddSubmonoid.LocalizationMap.sec f z).fst + ↑(-↑(IsAddUnit.liftRight (AddMonoidHom.restrict g S) hg) (AddSubmonoid.LocalizationMap.sec f z).snd), map_zero' := (_ : (fun z => ↑g (AddSubmonoid.LocalizationMap.sec f z).fst + ↑(-↑(IsAddUnit.liftRight (AddMonoidHom.restrict g S) hg) (AddSubmonoid.LocalizationMap.sec f z).snd)) 0 = 0) } (x + y) = ZeroHom.toFun { toFun := fun z => ↑g (AddSubmonoid.LocalizationMap.sec f z).fst + ↑(-↑(IsAddUnit.liftRight (AddMonoidHom.restrict g S) hg) (AddSubmonoid.LocalizationMap.sec f z).snd), map_zero' := (_ : (fun z => ↑g (AddSubmonoid.LocalizationMap.sec f z).fst + ↑(-↑(IsAddUnit.liftRight (AddMonoidHom.restrict g S) hg) (AddSubmonoid.LocalizationMap.sec f z).snd)) 0 = 0) } x + ZeroHom.toFun { toFun := fun z => ↑g (AddSubmonoid.LocalizationMap.sec f z).fst + ↑(-↑(IsAddUnit.liftRight (AddMonoidHom.restrict g S) hg) (AddSubmonoid.LocalizationMap.sec f z).snd), map_zero' := (_ : (fun z => ↑g (AddSubmonoid.LocalizationMap.sec f z).fst + ↑(-↑(IsAddUnit.liftRight (AddMonoidHom.restrict g S) hg) (AddSubmonoid.LocalizationMap.sec f z).snd)) 0 = 0) } 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 : Submonoid.LocalizationMap S N) {g : M →* P} (hg : ∀ (y : { x // x ∈ 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

• One or more equations did not get rendered due to their size.

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 : AddSubmonoid.LocalizationMap S N) {g : M →+ P} (hg : ∀ (y : { x // x ∈ S }), IsAddUnit (↑g ↑y)) (x : M) (y : { x // x ∈ S }) : ↑(AddSubmonoid.LocalizationMap.lift f hg) (AddSubmonoid.LocalizationMap.mk' f x y) = ↑g x + ↑(-↑(IsAddUnit.liftRight (AddMonoidHom.restrict g 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_mk' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : Submonoid.LocalizationMap S N) {g : M →* P} (hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)) (x : M) (y : { x // x ∈ S }) : ↑(Submonoid.LocalizationMap.lift f hg) (Submonoid.LocalizationMap.mk' f x y) = ↑g x * ↑(↑(IsUnit.liftRight (MonoidHom.restrict g 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_spec {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : AddSubmonoid.LocalizationMap S N) {g : M →+ P} (hg : ∀ (y : { x // x ∈ S }), IsAddUnit (↑g ↑y)) (z : N) (v : P) : ↑(AddSubmonoid.LocalizationMap.lift f hg) z = v ↔ ↑g (AddSubmonoid.LocalizationMap.sec f z).fst = ↑g ↑(AddSubmonoid.LocalizationMap.sec f z).snd + 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 {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : Submonoid.LocalizationMap S N) {g : M →* P} (hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)) (z : N) (v : (fun x => P) z) : ↑(Submonoid.LocalizationMap.lift f hg) z = v ↔ ↑g (Submonoid.LocalizationMap.sec f z).fst = ↑g ↑(Submonoid.LocalizationMap.sec f z).snd * 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_add {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : AddSubmonoid.LocalizationMap S N) {g : M →+ P} (hg : ∀ (y : { x // x ∈ S }), IsAddUnit (↑g ↑y)) (z : N) (w : P) (v : P) : ↑(AddSubmonoid.LocalizationMap.lift f hg) z + w = v ↔ ↑g (AddSubmonoid.LocalizationMap.sec f z).fst + w = ↑g ↑(AddSubmonoid.LocalizationMap.sec f z).snd + 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_spec_mul {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : Submonoid.LocalizationMap S N) {g : M →* P} (hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)) (z : N) (w : (fun x => P) z) (v : (fun x => P) z) : ↑(Submonoid.LocalizationMap.lift f hg) z * w = v ↔ ↑g (Submonoid.LocalizationMap.sec f z).fst * w = ↑g ↑(Submonoid.LocalizationMap.sec f z).snd * 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_mk'_spec {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : AddSubmonoid.LocalizationMap S N) {g : M →+ P} (hg : ∀ (y : { x // x ∈ S }), IsAddUnit (↑g ↑y)) (x : M) (v : P) (y : { x // x ∈ S }) : ↑(AddSubmonoid.LocalizationMap.lift f hg) (AddSubmonoid.LocalizationMap.mk' f x y) = v ↔ ↑g x = ↑g ↑y + v

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 : Submonoid.LocalizationMap S N) {g : M →* P} (hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)) (x : M) (v : P) (y : { x // x ∈ S }) : ↑(Submonoid.LocalizationMap.lift f hg) (Submonoid.LocalizationMap.mk' f x y) = v ↔ ↑g x = ↑g ↑y * v

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 : AddSubmonoid.LocalizationMap S N) {g : M →+ P} (hg : ∀ (y : { x // x ∈ S }), IsAddUnit (↑g ↑y)) (z : N) : ↑(AddSubmonoid.LocalizationMap.lift f hg) z + ↑g ↑(AddSubmonoid.LocalizationMap.sec f z).snd = ↑g (AddSubmonoid.LocalizationMap.sec f z).fst

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_right {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : Submonoid.LocalizationMap S N) {g : M →* P} (hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)) (z : N) : ↑(Submonoid.LocalizationMap.lift f hg) z * ↑g ↑(Submonoid.LocalizationMap.sec f z).snd = ↑g (Submonoid.LocalizationMap.sec f z).fst

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_left {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : AddSubmonoid.LocalizationMap S N) {g : M →+ P} (hg : ∀ (y : { x // x ∈ S }), IsAddUnit (↑g ↑y)) (z : N) : ↑g ↑(AddSubmonoid.LocalizationMap.sec f z).snd + ↑(AddSubmonoid.LocalizationMap.lift f hg) z = ↑g (AddSubmonoid.LocalizationMap.sec f z).fst

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.

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 : Submonoid.LocalizationMap S N) {g : M →* P} (hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)) (z : N) : ↑g ↑(Submonoid.LocalizationMap.sec f z).snd * ↑(Submonoid.LocalizationMap.lift f hg) z = ↑g (Submonoid.LocalizationMap.sec f z).fst

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.

@[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 : AddSubmonoid.LocalizationMap S N) {g : M →+ P} (hg : ∀ (y : { x // x ∈ S }), IsAddUnit (↑g ↑y)) (x : M) : ↑(AddSubmonoid.LocalizationMap.lift f hg) (↑(AddSubmonoid.LocalizationMap.toMap f) x) = ↑g 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 : Submonoid.LocalizationMap S N) {g : M →* P} (hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)) (x : M) : ↑(Submonoid.LocalizationMap.lift f hg) (↑(Submonoid.LocalizationMap.toMap f) x) = ↑g x

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 : AddSubmonoid.LocalizationMap S N) {g : M →+ P} (hg : ∀ (y : { x // x ∈ S }), IsAddUnit (↑g ↑y)) {x : M × { x // x ∈ S }} {y : M × { x // x ∈ S }} : ↑(AddSubmonoid.LocalizationMap.lift f hg) (AddSubmonoid.LocalizationMap.mk' f x.fst x.snd) = ↑(AddSubmonoid.LocalizationMap.lift f hg) (AddSubmonoid.LocalizationMap.mk' f y.fst y.snd) ↔ ↑g (x.fst + ↑y.snd) = ↑g (y.fst + ↑x.snd)

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 : Submonoid.LocalizationMap S N) {g : M →* P} (hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)) {x : M × { x // x ∈ S }} {y : M × { x // x ∈ S }} : ↑(Submonoid.LocalizationMap.lift f hg) (Submonoid.LocalizationMap.mk' f x.fst x.snd) = ↑(Submonoid.LocalizationMap.lift f hg) (Submonoid.LocalizationMap.mk' f y.fst y.snd) ↔ ↑g (x.fst * ↑y.snd) = ↑g (y.fst * ↑x.snd)

@[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 : AddSubmonoid.LocalizationMap S N) {g : M →+ P} (hg : ∀ (y : { x // x ∈ S }), IsAddUnit (↑g ↑y)) : AddMonoidHom.comp (AddSubmonoid.LocalizationMap.lift f hg) (AddSubmonoid.LocalizationMap.toMap f) = g

@[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 : Submonoid.LocalizationMap S N) {g : M →* P} (hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)) : MonoidHom.comp (Submonoid.LocalizationMap.lift f hg) (Submonoid.LocalizationMap.toMap f) = g

@[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 : AddSubmonoid.LocalizationMap S N) (j : N →+ P) : AddSubmonoid.LocalizationMap.lift f (_ : ∀ (y : { x // x ∈ S }), IsAddUnit (↑(AddMonoidHom.comp j (AddSubmonoid.LocalizationMap.toMap f)) ↑y)) = j

@[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 : Submonoid.LocalizationMap S N) (j : N →* P) : Submonoid.LocalizationMap.lift f (_ : ∀ (y : { x // x ∈ S }), IsUnit (↑(MonoidHom.comp j (Submonoid.LocalizationMap.toMap f)) ↑y)) = j

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 : AddSubmonoid.LocalizationMap S N) {j : N →+ P} {k : N →+ P} (h : ∀ (a : M), ↑(AddMonoidHom.comp j (AddSubmonoid.LocalizationMap.toMap f)) a = ↑(AddMonoidHom.comp k (AddSubmonoid.LocalizationMap.toMap f)) a) : j = k

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 : Submonoid.LocalizationMap S N) {j : N →* P} {k : N →* P} (h : ∀ (a : M), ↑(MonoidHom.comp j (Submonoid.LocalizationMap.toMap f)) a = ↑(MonoidHom.comp k (Submonoid.LocalizationMap.toMap f)) a) : j = k

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 : AddSubmonoid.LocalizationMap S N) {g : M →+ P} (hg : ∀ (y : { x // x ∈ S }), IsAddUnit (↑g ↑y)) {j : N →+ P} (hj : ∀ (x : M), ↑j (↑(AddSubmonoid.LocalizationMap.toMap f) x) = ↑g x) : AddSubmonoid.LocalizationMap.lift f hg = j

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 : Submonoid.LocalizationMap S N) {g : M →* P} (hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)) {j : N →* P} (hj : ∀ (x : M), ↑j (↑(Submonoid.LocalizationMap.toMap f) x) = ↑g x) : Submonoid.LocalizationMap.lift f hg = j

@[simp]

theorem AddSubmonoid.LocalizationMap.lift_id {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) (x : N) : ↑(AddSubmonoid.LocalizationMap.lift f (_ : ∀ (y : { x // x ∈ S }), IsAddUnit (↑(AddSubmonoid.LocalizationMap.toMap f) ↑y))) x = x

@[simp]

theorem Submonoid.LocalizationMap.lift_id {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) (x : N) : ↑(Submonoid.LocalizationMap.lift f (_ : ∀ (y : { x // x ∈ S }), IsUnit (↑(Submonoid.LocalizationMap.toMap f) ↑y))) x = x

@[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 : AddSubmonoid.LocalizationMap S N) {k : AddSubmonoid.LocalizationMap S P} (z : N) : ↑(AddSubmonoid.LocalizationMap.lift k (_ : ∀ (y : { x // x ∈ S }), IsAddUnit (↑(AddSubmonoid.LocalizationMap.toMap f) ↑y))) (↑(AddSubmonoid.LocalizationMap.lift f (_ : ∀ (y : { x // x ∈ S }), IsAddUnit (↑(AddSubmonoid.LocalizationMap.toMap k) ↑y))) 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 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 : Submonoid.LocalizationMap S N) {k : Submonoid.LocalizationMap S P} (z : N) : ↑(Submonoid.LocalizationMap.lift k (_ : ∀ (y : { x // x ∈ S }), IsUnit (↑(Submonoid.LocalizationMap.toMap f) ↑y))) (↑(Submonoid.LocalizationMap.lift f (_ : ∀ (y : { x // x ∈ S }), IsUnit (↑(Submonoid.LocalizationMap.toMap k) ↑y))) 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 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 : AddSubmonoid.LocalizationMap S N) {g : M →+ P} (hg : ∀ (y : { x // x ∈ S }), IsAddUnit (↑g ↑y)) : Function.Surjective ↑(AddSubmonoid.LocalizationMap.lift f hg) ↔ ∀ (v : P), ∃ x, v + ↑g ↑x.snd = ↑g x.fst

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 : Submonoid.LocalizationMap S N) {g : M →* P} (hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)) : Function.Surjective ↑(Submonoid.LocalizationMap.lift f hg) ↔ ∀ (v : P), ∃ x, v * ↑g ↑x.snd = ↑g x.fst

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 : AddSubmonoid.LocalizationMap S N) {g : M →+ P} (hg : ∀ (y : { x // x ∈ S }), IsAddUnit (↑g ↑y)) : Function.Injective ↑(AddSubmonoid.LocalizationMap.lift f hg) ↔ ∀ (x y : M), ↑(AddSubmonoid.LocalizationMap.toMap f) x = ↑(AddSubmonoid.LocalizationMap.toMap f) y ↔ ↑g x = ↑g y

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 : Submonoid.LocalizationMap S N) {g : M →* P} (hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)) : Function.Injective ↑(Submonoid.LocalizationMap.lift f hg) ↔ ∀ (x y : M), ↑(Submonoid.LocalizationMap.toMap f) x = ↑(Submonoid.LocalizationMap.toMap f) y ↔ ↑g x = ↑g y

theorem AddSubmonoid.LocalizationMap.map.proof_1 {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {P : Type u_3} [AddCommMonoid P] {g : M →+ P} {T : AddSubmonoid P} (hy : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T) {Q : Type u_2} [AddCommMonoid Q] (k : AddSubmonoid.LocalizationMap T Q) (y : { x // x ∈ S }) : IsAddUnit (↑(AddSubmonoid.LocalizationMap.toMap k) ↑{ val := ↑g ↑y, property := hy y })

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 : AddSubmonoid.LocalizationMap S N) {g : M →+ P} {T : AddSubmonoid P} (hy : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T) {Q : Type u_4} [AddCommMonoid Q] (k : AddSubmonoid.LocalizationMap T 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

• One or more equations did not get rendered due to their size.

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 : Submonoid.LocalizationMap S N) {g : M →* P} {T : Submonoid P} (hy : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T) {Q : Type u_4} [CommMonoid Q] (k : Submonoid.LocalizationMap T 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

• Submonoid.LocalizationMap.map f hy k = Submonoid.LocalizationMap.lift f (_ : ∀ (y : { x // x ∈ S }), IsUnit (↑(Submonoid.LocalizationMap.toMap k) ↑{ val := ↑g ↑y, property := hy y }))

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 : AddSubmonoid.LocalizationMap S N) {g : M →+ P} {T : AddSubmonoid P} (hy : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T) {Q : Type u_4} [AddCommMonoid Q] {k : AddSubmonoid.LocalizationMap T Q} (x : M) : ↑(AddSubmonoid.LocalizationMap.map f hy k) (↑(AddSubmonoid.LocalizationMap.toMap f) x) = ↑(AddSubmonoid.LocalizationMap.toMap k) (↑g x)

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 : Submonoid.LocalizationMap S N) {g : M →* P} {T : Submonoid P} (hy : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T) {Q : Type u_4} [CommMonoid Q] {k : Submonoid.LocalizationMap T Q} (x : M) : ↑(Submonoid.LocalizationMap.map f hy k) (↑(Submonoid.LocalizationMap.toMap f) x) = ↑(Submonoid.LocalizationMap.toMap k) (↑g x)

@[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 : AddSubmonoid.LocalizationMap S N) {g : M →+ P} {T : AddSubmonoid P} (hy : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T) {Q : Type u_4} [AddCommMonoid Q] {k : AddSubmonoid.LocalizationMap T Q} : AddMonoidHom.comp (AddSubmonoid.LocalizationMap.map f hy k) (AddSubmonoid.LocalizationMap.toMap f) = AddMonoidHom.comp (AddSubmonoid.LocalizationMap.toMap k) g

@[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 : Submonoid.LocalizationMap S N) {g : M →* P} {T : Submonoid P} (hy : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T) {Q : Type u_4} [CommMonoid Q] {k : Submonoid.LocalizationMap T Q} : MonoidHom.comp (Submonoid.LocalizationMap.map f hy k) (Submonoid.LocalizationMap.toMap f) = MonoidHom.comp (Submonoid.LocalizationMap.toMap k) g

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 : AddSubmonoid.LocalizationMap S N) {g : M →+ P} {T : AddSubmonoid P} (hy : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T) {Q : Type u_4} [AddCommMonoid Q] {k : AddSubmonoid.LocalizationMap T Q} (x : M) (y : { x // x ∈ S }) : ↑(AddSubmonoid.LocalizationMap.map f hy k) (AddSubmonoid.LocalizationMap.mk' f x y) = AddSubmonoid.LocalizationMap.mk' k (↑g x) { val := ↑g ↑y, property := hy y }

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 : Submonoid.LocalizationMap S N) {g : M →* P} {T : Submonoid P} (hy : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T) {Q : Type u_4} [CommMonoid Q] {k : Submonoid.LocalizationMap T Q} (x : M) (y : { x // x ∈ S }) : ↑(Submonoid.LocalizationMap.map f hy k) (Submonoid.LocalizationMap.mk' f x y) = Submonoid.LocalizationMap.mk' k (↑g x) { val := ↑g ↑y, property := hy y }

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 : AddSubmonoid.LocalizationMap S N) {g : M →+ P} {T : AddSubmonoid P} (hy : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T) {Q : Type u_4} [AddCommMonoid Q] {k : AddSubmonoid.LocalizationMap T Q} (z : N) (u : Q) : ↑(AddSubmonoid.LocalizationMap.map f hy k) z = u ↔ ↑(AddSubmonoid.LocalizationMap.toMap k) (↑g (AddSubmonoid.LocalizationMap.sec f z).fst) = ↑(AddSubmonoid.LocalizationMap.toMap k) (↑g ↑(AddSubmonoid.LocalizationMap.sec f z).snd) + 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_spec {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : Submonoid.LocalizationMap S N) {g : M →* P} {T : Submonoid P} (hy : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T) {Q : Type u_4} [CommMonoid Q] {k : Submonoid.LocalizationMap T Q} (z : N) (u : (fun x => Q) z) : ↑(Submonoid.LocalizationMap.map f hy k) z = u ↔ ↑(Submonoid.LocalizationMap.toMap k) (↑g (Submonoid.LocalizationMap.sec f z).fst) = ↑(Submonoid.LocalizationMap.toMap k) (↑g ↑(Submonoid.LocalizationMap.sec f z).snd) * 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_add_right {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : AddSubmonoid.LocalizationMap S N) {g : M →+ P} {T : AddSubmonoid P} (hy : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T) {Q : Type u_4} [AddCommMonoid Q] {k : AddSubmonoid.LocalizationMap T Q} (z : N) : ↑(AddSubmonoid.LocalizationMap.map f hy k) z + ↑(AddSubmonoid.LocalizationMap.toMap k) (↑g ↑(AddSubmonoid.LocalizationMap.sec f z).snd) = ↑(AddSubmonoid.LocalizationMap.toMap k) (↑g (AddSubmonoid.LocalizationMap.sec f z).fst)

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_right {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : Submonoid.LocalizationMap S N) {g : M →* P} {T : Submonoid P} (hy : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T) {Q : Type u_4} [CommMonoid Q] {k : Submonoid.LocalizationMap T Q} (z : N) : ↑(Submonoid.LocalizationMap.map f hy k) z * ↑(Submonoid.LocalizationMap.toMap k) (↑g ↑(Submonoid.LocalizationMap.sec f z).snd) = ↑(Submonoid.LocalizationMap.toMap k) (↑g (Submonoid.LocalizationMap.sec f z).fst)

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_left {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : AddSubmonoid.LocalizationMap S N) {g : M →+ P} {T : AddSubmonoid P} (hy : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T) {Q : Type u_4} [AddCommMonoid Q] {k : AddSubmonoid.LocalizationMap T Q} (z : N) : ↑(AddSubmonoid.LocalizationMap.toMap k) (↑g ↑(AddSubmonoid.LocalizationMap.sec f z).snd) + ↑(AddSubmonoid.LocalizationMap.map f hy k) z = ↑(AddSubmonoid.LocalizationMap.toMap k) (↑g (AddSubmonoid.LocalizationMap.sec f z).fst)

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.

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 : Submonoid.LocalizationMap S N) {g : M →* P} {T : Submonoid P} (hy : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T) {Q : Type u_4} [CommMonoid Q] {k : Submonoid.LocalizationMap T Q} (z : N) : ↑(Submonoid.LocalizationMap.toMap k) (↑g ↑(Submonoid.LocalizationMap.sec f z).snd) * ↑(Submonoid.LocalizationMap.map f hy k) z = ↑(Submonoid.LocalizationMap.toMap k) (↑g (Submonoid.LocalizationMap.sec f z).fst)

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.

@[simp]

theorem AddSubmonoid.LocalizationMap.map_id {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) (z : N) : ↑(AddSubmonoid.LocalizationMap.map f (_ : ∀ (y : { x // x ∈ S }), ↑(AddMonoidHom.id M) ↑y ∈ S) f) z = z

@[simp]

theorem Submonoid.LocalizationMap.map_id {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) (z : N) : ↑(Submonoid.LocalizationMap.map f (_ : ∀ (y : { x // x ∈ S }), ↑(MonoidHom.id M) ↑y ∈ S) f) z = z

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 : AddSubmonoid.LocalizationMap S N) {g : M →+ P} {T : AddSubmonoid P} (hy : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T) {Q : Type u_4} [AddCommMonoid Q] {k : AddSubmonoid.LocalizationMap T Q} {A : Type u_5} [AddCommMonoid A] {U : AddSubmonoid A} {R : Type u_6} [AddCommMonoid R] (j : AddSubmonoid.LocalizationMap U R) {l : P →+ A} (hl : ∀ (w : { x // x ∈ T }), ↑l ↑w ∈ U) : AddMonoidHom.comp (AddSubmonoid.LocalizationMap.map k hl j) (AddSubmonoid.LocalizationMap.map f hy k) = AddSubmonoid.LocalizationMap.map f (_ : ∀ (x : { x // x ∈ S }), ↑(AddMonoidHom.comp l g) ↑x ∈ U) 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_comp_map {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : Submonoid.LocalizationMap S N) {g : M →* P} {T : Submonoid P} (hy : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T) {Q : Type u_4} [CommMonoid Q] {k : Submonoid.LocalizationMap T Q} {A : Type u_5} [CommMonoid A] {U : Submonoid A} {R : Type u_6} [CommMonoid R] (j : Submonoid.LocalizationMap U R) {l : P →* A} (hl : ∀ (w : { x // x ∈ T }), ↑l ↑w ∈ U) : MonoidHom.comp (Submonoid.LocalizationMap.map k hl j) (Submonoid.LocalizationMap.map f hy k) = Submonoid.LocalizationMap.map f (_ : ∀ (x : { x // x ∈ S }), ↑(MonoidHom.comp l g) ↑x ∈ U) 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_map {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : AddSubmonoid.LocalizationMap S N) {g : M →+ P} {T : AddSubmonoid P} (hy : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T) {Q : Type u_4} [AddCommMonoid Q] {k : AddSubmonoid.LocalizationMap T Q} {A : Type u_5} [AddCommMonoid A] {U : AddSubmonoid A} {R : Type u_6} [AddCommMonoid R] (j : AddSubmonoid.LocalizationMap U R) {l : P →+ A} (hl : ∀ (w : { x // x ∈ T }), ↑l ↑w ∈ U) (x : N) : ↑(AddSubmonoid.LocalizationMap.map k hl j) (↑(AddSubmonoid.LocalizationMap.map f hy k) x) = ↑(AddSubmonoid.LocalizationMap.map f (_ : ∀ (x : { x // x ∈ S }), ↑(AddMonoidHom.comp l g) ↑x ∈ U) 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_map {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : Submonoid.LocalizationMap S N) {g : M →* P} {T : Submonoid P} (hy : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T) {Q : Type u_4} [CommMonoid Q] {k : Submonoid.LocalizationMap T Q} {A : Type u_5} [CommMonoid A] {U : Submonoid A} {R : Type u_6} [CommMonoid R] (j : Submonoid.LocalizationMap U R) {l : P →* A} (hl : ∀ (w : { x // x ∈ T }), ↑l ↑w ∈ U) (x : N) : ↑(Submonoid.LocalizationMap.map k hl j) (↑(Submonoid.LocalizationMap.map f hy k) x) = ↑(Submonoid.LocalizationMap.map f (_ : ∀ (x : { x // x ∈ S }), ↑(MonoidHom.comp l g) ↑x ∈ U) 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.

@[reducible]

def AddSubmonoid.LocalizationMap.AwayMap {M : Type u_1} [AddCommMonoid M] (x : M) (N' : Type u_5) [AddCommMonoid N'] : Type (max u_1 u_5)

Given x : M, the type of AddCommMonoid homomorphisms f : M →+ N such that N is isomorphic to the localization of M at the AddSubmonoid generated by x.

Equations

• AddSubmonoid.LocalizationMap.AwayMap x N' = AddSubmonoid.LocalizationMap (AddSubmonoid.multiples x) N'

@[reducible]

def Submonoid.LocalizationMap.AwayMap {M : Type u_1} [CommMonoid M] (x : M) (N' : Type u_5) [CommMonoid N'] : Type (max u_1 u_5)

Given x : M, the type of CommMonoid homomorphisms f : M →* N such that N is isomorphic to the Localization of M at the Submonoid generated by x.

Equations

• Submonoid.LocalizationMap.AwayMap x N' = Submonoid.LocalizationMap (Submonoid.powers x) N'

noncomputable def Submonoid.LocalizationMap.AwayMap.invSelf {M : Type u_1} [CommMonoid M] {N : Type u_2} [CommMonoid N] (x : M) (F : Submonoid.LocalizationMap.AwayMap x N) : N

Given x : M and a Localization map F : M →* N away from x, invSelf is (F x)⁻¹.

Equations

• Submonoid.LocalizationMap.AwayMap.invSelf x F = Submonoid.LocalizationMap.mk' F 1 { val := x, property := (_ : x ∈ Submonoid.powers x) }

noncomputable def Submonoid.LocalizationMap.AwayMap.lift {M : Type u_1} [CommMonoid M] {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] {g : M →* P} (x : M) (F : Submonoid.LocalizationMap.AwayMap x N) (hg : IsUnit (↑g x)) : N →* P

Given x : M, a Localization map F : M →* N away from x, and a map of CommMonoids g : M →* P such that g x is invertible, the homomorphism induced from N to P sending z : N to g y * (g x)⁻ⁿ, where y : M, n : ℕ are such that z = F y * (F x)⁻ⁿ.

Equations

• Submonoid.LocalizationMap.AwayMap.lift x F hg = Submonoid.LocalizationMap.lift F (_ : ∀ (y : { x // x ∈ Submonoid.powers x }), IsUnit (↑g ↑y))

@[simp]

theorem Submonoid.LocalizationMap.AwayMap.lift_eq {M : Type u_1} [CommMonoid M] {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] {g : M →* P} (x : M) (F : Submonoid.LocalizationMap.AwayMap x N) (hg : IsUnit (↑g x)) (a : M) : ↑(Submonoid.LocalizationMap.AwayMap.lift x F hg) (↑(Submonoid.LocalizationMap.toMap F) a) = ↑g a

@[simp]

theorem Submonoid.LocalizationMap.AwayMap.lift_comp {M : Type u_1} [CommMonoid M] {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] {g : M →* P} (x : M) (F : Submonoid.LocalizationMap.AwayMap x N) (hg : IsUnit (↑g x)) : MonoidHom.comp (Submonoid.LocalizationMap.AwayMap.lift x F hg) (Submonoid.LocalizationMap.toMap F) = g

noncomputable def Submonoid.LocalizationMap.awayToAwayRight {M : Type u_1} [CommMonoid M] {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (x : M) (F : Submonoid.LocalizationMap.AwayMap x N) (y : M) (G : Submonoid.LocalizationMap.AwayMap (x * y) P) : N →* P

Given x y : M and Localization maps F : M →* N, G : M →* P away from x and x * y respectively, the homomorphism induced from N to P.

Equations

• Submonoid.LocalizationMap.awayToAwayRight x F y G = Submonoid.LocalizationMap.AwayMap.lift x F (_ : IsUnit (↑(Submonoid.LocalizationMap.toMap G) x))

noncomputable def AddSubmonoid.LocalizationMap.AwayMap.negSelf {A : Type u_4} [AddCommMonoid A] (x : A) {B : Type u_5} [AddCommMonoid B] (F : AddSubmonoid.LocalizationMap.AwayMap x B) : B

Given x : A and a Localization map F : A →+ B away from x, neg_self is - (F x).

Equations

• AddSubmonoid.LocalizationMap.AwayMap.negSelf x F = AddSubmonoid.LocalizationMap.mk' F 0 { val := x, property := (_ : x ∈ AddSubmonoid.multiples x) }

noncomputable def AddSubmonoid.LocalizationMap.AwayMap.lift {A : Type u_4} [AddCommMonoid A] (x : A) {B : Type u_5} [AddCommMonoid B] (F : AddSubmonoid.LocalizationMap.AwayMap x B) {C : Type u_6} [AddCommMonoid C] {g : A →+ C} (hg : IsAddUnit (↑g x)) : B →+ C

Given x : A, a localization map F : A →+ B away from x, and a map of AddCommMonoids g : A →+ C such that g x is invertible, the homomorphism induced from B to C sending z : B to g y - n • g x, where y : A, n : ℕ are such that z = F y - n • F x.

Equations

• AddSubmonoid.LocalizationMap.AwayMap.lift x F hg = AddSubmonoid.LocalizationMap.lift F (_ : ∀ (y : { x // x ∈ AddSubmonoid.multiples x }), IsAddUnit (↑g ↑y))

@[simp]

theorem AddSubmonoid.LocalizationMap.AwayMap.lift_eq {A : Type u_4} [AddCommMonoid A] (x : A) {B : Type u_5} [AddCommMonoid B] (F : AddSubmonoid.LocalizationMap.AwayMap x B) {C : Type u_6} [AddCommMonoid C] {g : A →+ C} (hg : IsAddUnit (↑g x)) (a : A) : ↑(AddSubmonoid.LocalizationMap.AwayMap.lift x F hg) (↑(AddSubmonoid.LocalizationMap.toMap F) a) = ↑g a

@[simp]

theorem AddSubmonoid.LocalizationMap.AwayMap.lift_comp {A : Type u_4} [AddCommMonoid A] (x : A) {B : Type u_5} [AddCommMonoid B] (F : AddSubmonoid.LocalizationMap.AwayMap x B) {C : Type u_6} [AddCommMonoid C] {g : A →+ C} (hg : IsAddUnit (↑g x)) : AddMonoidHom.comp (AddSubmonoid.LocalizationMap.AwayMap.lift x F hg) (AddSubmonoid.LocalizationMap.toMap F) = g

noncomputable def AddSubmonoid.LocalizationMap.awayToAwayRight {A : Type u_4} [AddCommMonoid A] (x : A) {B : Type u_5} [AddCommMonoid B] (F : AddSubmonoid.LocalizationMap.AwayMap x B) {C : Type u_6} [AddCommMonoid C] (y : A) (G : AddSubmonoid.LocalizationMap.AwayMap (x + y) C) : B →+ C

Given x y : A and Localization maps F : A →+ B, G : A →+ C away from x and x + y respectively, the homomorphism induced from B to C.

Equations

• AddSubmonoid.LocalizationMap.awayToAwayRight x F y G = AddSubmonoid.LocalizationMap.AwayMap.lift x F (_ : IsAddUnit (↑(AddSubmonoid.LocalizationMap.toMap G) x))

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 : AddSubmonoid.LocalizationMap S N) (k : AddSubmonoid.LocalizationMap S 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

• One or more equations did not get rendered due to their size.

theorem AddSubmonoid.LocalizationMap.addEquivOfLocalizations.proof_1 {M : Type u_3} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_1} [AddCommMonoid P] (f : AddSubmonoid.LocalizationMap S N) (k : AddSubmonoid.LocalizationMap S P) (a : N) (b : N) : ↑(AddSubmonoid.LocalizationMap.lift f (_ : ∀ (y : { x // x ∈ S }), IsAddUnit (↑(AddSubmonoid.LocalizationMap.toMap k) ↑y))) (a + b) = ↑(AddSubmonoid.LocalizationMap.lift f (_ : ∀ (y : { x // x ∈ S }), IsAddUnit (↑(AddSubmonoid.LocalizationMap.toMap k) ↑y))) a + ↑(AddSubmonoid.LocalizationMap.lift f (_ : ∀ (y : { x // x ∈ S }), IsAddUnit (↑(AddSubmonoid.LocalizationMap.toMap k) ↑y))) b

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 : Submonoid.LocalizationMap S N) (k : Submonoid.LocalizationMap S 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

• One or more equations did not get rendered due to their size.

@[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 : AddSubmonoid.LocalizationMap S N) {k : AddSubmonoid.LocalizationMap S P} {x : N} : ↑(AddSubmonoid.LocalizationMap.addEquivOfLocalizations f k) x = ↑(AddSubmonoid.LocalizationMap.lift f (_ : ∀ (y : { x // x ∈ S }), IsAddUnit (↑(AddSubmonoid.LocalizationMap.toMap k) ↑y))) x

@[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 : Submonoid.LocalizationMap S N) {k : Submonoid.LocalizationMap S P} {x : N} : ↑(Submonoid.LocalizationMap.mulEquivOfLocalizations f k) x = ↑(Submonoid.LocalizationMap.lift f (_ : ∀ (y : { x // x ∈ S }), IsUnit (↑(Submonoid.LocalizationMap.toMap k) ↑y))) 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 : AddSubmonoid.LocalizationMap S N) {k : AddSubmonoid.LocalizationMap S P} {x : P} : ↑(AddEquiv.symm (AddSubmonoid.LocalizationMap.addEquivOfLocalizations f k)) x = ↑(AddSubmonoid.LocalizationMap.lift k (_ : ∀ (y : { x // x ∈ S }), IsAddUnit (↑(AddSubmonoid.LocalizationMap.toMap f) ↑y))) 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 : Submonoid.LocalizationMap S N) {k : Submonoid.LocalizationMap S P} {x : P} : ↑(MulEquiv.symm (Submonoid.LocalizationMap.mulEquivOfLocalizations f k)) x = ↑(Submonoid.LocalizationMap.lift k (_ : ∀ (y : { x // x ∈ S }), IsUnit (↑(Submonoid.LocalizationMap.toMap f) ↑y))) x

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 : AddSubmonoid.LocalizationMap S N) {k : AddSubmonoid.LocalizationMap S P} : AddEquiv.symm (AddSubmonoid.LocalizationMap.addEquivOfLocalizations k f) = AddSubmonoid.LocalizationMap.addEquivOfLocalizations f k

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 : Submonoid.LocalizationMap S N) {k : Submonoid.LocalizationMap S P} : MulEquiv.symm (Submonoid.LocalizationMap.mulEquivOfLocalizations k f) = Submonoid.LocalizationMap.mulEquivOfLocalizations f k

abbrev AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations.match_1 {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) (z : N) (motive : (∃ x, z + ↑(AddSubmonoid.LocalizationMap.toMap f) ↑x.snd = ↑(AddSubmonoid.LocalizationMap.toMap f) x.fst) → Prop) : (x : ∃ x, z + ↑(AddSubmonoid.LocalizationMap.toMap f) ↑x.snd = ↑(AddSubmonoid.LocalizationMap.toMap f) x.fst) → ((x : M × { x // x ∈ S }) → (hx : z + ↑(AddSubmonoid.LocalizationMap.toMap f) ↑x.snd = ↑(AddSubmonoid.LocalizationMap.toMap f) x.fst) → motive (_ : ∃ x, z + ↑(AddSubmonoid.LocalizationMap.toMap f) ↑x.snd = ↑(AddSubmonoid.LocalizationMap.toMap f) x.fst)) → motive x

Equations

• AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations.match_1 f z motive x h_1 = Exists.casesOn x fun w h => h_1 w h

theorem AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations.proof_2 {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_3} [AddCommMonoid N] {P : Type u_2} [AddCommMonoid P] (f : AddSubmonoid.LocalizationMap S N) (k : N ≃+ P) (v : P) : ∃ x, v + ↑(AddMonoidHom.comp (AddEquiv.toAddMonoidHom k) (AddSubmonoid.LocalizationMap.toMap f)) ↑x.snd = ↑(AddMonoidHom.comp (AddEquiv.toAddMonoidHom k) (AddSubmonoid.LocalizationMap.toMap f)) x.fst

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 : AddSubmonoid.LocalizationMap S N) (k : N ≃+ P) : AddSubmonoid.LocalizationMap S 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

• One or more equations did not get rendered due to their size.

theorem AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations.proof_1 {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_3} [AddCommMonoid N] {P : Type u_2} [AddCommMonoid P] (f : AddSubmonoid.LocalizationMap S N) (k : N ≃+ P) (y : { x // x ∈ S }) : IsAddUnit (↑(AddMonoidHom.comp (AddEquiv.toAddMonoidHom k) (AddSubmonoid.LocalizationMap.toMap f)) ↑y)

theorem AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations.proof_3 {M : Type u_3} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_1} [AddCommMonoid P] (f : AddSubmonoid.LocalizationMap S N) (k : N ≃+ P) (x : M) (y : M) : ↑k (↑(AddSubmonoid.LocalizationMap.toMap f) x) = ↑k (↑(AddSubmonoid.LocalizationMap.toMap f) y) ↔ ∃ c, ↑c + x = ↑c + y

abbrev AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations.match_2 {N : Type u_1} [AddCommMonoid N] {P : Type u_2} [AddCommMonoid P] (k : N ≃+ P) (v : P) (motive : (∃ a, ↑k.toEquiv a = v) → Prop) : (x : ∃ a, ↑k.toEquiv a = v) → ((z : N) → (hz : ↑k.toEquiv z = v) → motive (_ : ∃ a, ↑k.toEquiv a = v)) → motive x

Equations

• AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations.match_2 k v motive x h_1 = Exists.casesOn x fun w h => h_1 w h

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 : Submonoid.LocalizationMap S N) (k : N ≃* P) : Submonoid.LocalizationMap S 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

• One or more equations did not get rendered due to their size.

@[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 : AddSubmonoid.LocalizationMap S N) {k : N ≃+ P} (x : M) : ↑(AddSubmonoid.LocalizationMap.toMap (AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations f k)) x = ↑k (↑(AddSubmonoid.LocalizationMap.toMap f) x)

@[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 : Submonoid.LocalizationMap S N) {k : N ≃* P} (x : M) : ↑(Submonoid.LocalizationMap.toMap (Submonoid.LocalizationMap.ofMulEquivOfLocalizations f k)) x = ↑k (↑(Submonoid.LocalizationMap.toMap f) x)

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 : AddSubmonoid.LocalizationMap S N) {k : N ≃+ P} : AddSubmonoid.LocalizationMap.toMap (AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations f k) = AddMonoidHom.comp (AddEquiv.toAddMonoidHom k) (AddSubmonoid.LocalizationMap.toMap f)

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 : Submonoid.LocalizationMap S N) {k : N ≃* P} : Submonoid.LocalizationMap.toMap (Submonoid.LocalizationMap.ofMulEquivOfLocalizations f k) = MonoidHom.comp (MulEquiv.toMonoidHom k) (Submonoid.LocalizationMap.toMap f)

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 : AddSubmonoid.LocalizationMap S N) {k : N ≃+ P} (x : M) : ↑(AddEquiv.symm k) (↑(AddSubmonoid.LocalizationMap.toMap (AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations f k)) x) = ↑(AddSubmonoid.LocalizationMap.toMap f) 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 : Submonoid.LocalizationMap S N) {k : N ≃* P} (x : M) : ↑(MulEquiv.symm k) (↑(Submonoid.LocalizationMap.toMap (Submonoid.LocalizationMap.ofMulEquivOfLocalizations f k)) x) = ↑(Submonoid.LocalizationMap.toMap f) 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 : AddSubmonoid.LocalizationMap S N) {k : P ≃+ N} (x : M) : ↑k (↑(AddSubmonoid.LocalizationMap.toMap (AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations f (AddEquiv.symm k))) x) = ↑(AddSubmonoid.LocalizationMap.toMap f) 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 : Submonoid.LocalizationMap S N) {k : P ≃* N} (x : M) : ↑k (↑(Submonoid.LocalizationMap.toMap (Submonoid.LocalizationMap.ofMulEquivOfLocalizations f (MulEquiv.symm k))) x) = ↑(Submonoid.LocalizationMap.toMap f) x

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 : AddSubmonoid.LocalizationMap S N) {k : N ≃+ P} {x : M} {y : P} : ↑(AddSubmonoid.LocalizationMap.toMap (AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations f k)) x = y ↔ ↑(AddSubmonoid.LocalizationMap.toMap f) x = ↑(AddEquiv.symm k) y

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 : Submonoid.LocalizationMap S N) {k : N ≃* P} {x : M} {y : (fun x => P) x} : ↑(Submonoid.LocalizationMap.toMap (Submonoid.LocalizationMap.ofMulEquivOfLocalizations f k)) x = y ↔ ↑(Submonoid.LocalizationMap.toMap f) x = ↑(MulEquiv.symm k) y

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 : AddSubmonoid.LocalizationMap S N) (k : AddSubmonoid.LocalizationMap S P) : AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations f (AddSubmonoid.LocalizationMap.addEquivOfLocalizations f k) = k

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 : Submonoid.LocalizationMap S N) (k : Submonoid.LocalizationMap S P) : Submonoid.LocalizationMap.ofMulEquivOfLocalizations f (Submonoid.LocalizationMap.mulEquivOfLocalizations f k) = k

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 : AddSubmonoid.LocalizationMap S N) {k : AddSubmonoid.LocalizationMap S P} {x : M} : ↑(AddSubmonoid.LocalizationMap.toMap (AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations f (AddSubmonoid.LocalizationMap.addEquivOfLocalizations f k))) x = ↑(AddSubmonoid.LocalizationMap.toMap k) x

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 : Submonoid.LocalizationMap S N) {k : Submonoid.LocalizationMap S P} {x : M} : ↑(Submonoid.LocalizationMap.toMap (Submonoid.LocalizationMap.ofMulEquivOfLocalizations f (Submonoid.LocalizationMap.mulEquivOfLocalizations f k))) x = ↑(Submonoid.LocalizationMap.toMap k) x

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 : AddSubmonoid.LocalizationMap S N) (k : N ≃+ P) : AddSubmonoid.LocalizationMap.addEquivOfLocalizations f (AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations f k) = k

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 : Submonoid.LocalizationMap S N) (k : N ≃* P) : Submonoid.LocalizationMap.mulEquivOfLocalizations f (Submonoid.LocalizationMap.ofMulEquivOfLocalizations f k) = k

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 : AddSubmonoid.LocalizationMap S N) {k : N ≃+ P} (x : N) : ↑(AddSubmonoid.LocalizationMap.addEquivOfLocalizations f (AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations f k)) x = ↑k x

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 : Submonoid.LocalizationMap S N) {k : N ≃* P} (x : N) : ↑(Submonoid.LocalizationMap.mulEquivOfLocalizations f (Submonoid.LocalizationMap.ofMulEquivOfLocalizations f k)) x = ↑k x

@[simp]

theorem AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations_id {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) : AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations f (AddEquiv.refl N) = f

@[simp]

theorem Submonoid.LocalizationMap.ofMulEquivOfLocalizations_id {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) : Submonoid.LocalizationMap.ofMulEquivOfLocalizations f (MulEquiv.refl N) = f

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 : AddSubmonoid.LocalizationMap S N) {Q : Type u_4} [AddCommMonoid Q] {k : N ≃+ P} {j : P ≃+ Q} : AddSubmonoid.LocalizationMap.toMap (AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations f (AddEquiv.trans k j)) = AddMonoidHom.comp (AddEquiv.toAddMonoidHom j) (AddSubmonoid.LocalizationMap.toMap (AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations f k))

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 : Submonoid.LocalizationMap S N) {Q : Type u_4} [CommMonoid Q] {k : N ≃* P} {j : P ≃* Q} : Submonoid.LocalizationMap.toMap (Submonoid.LocalizationMap.ofMulEquivOfLocalizations f (MulEquiv.trans k j)) = MonoidHom.comp (MulEquiv.toMonoidHom j) (Submonoid.LocalizationMap.toMap (Submonoid.LocalizationMap.ofMulEquivOfLocalizations f k))

theorem AddSubmonoid.LocalizationMap.ofAddEquivOfDom.proof_2 {M : Type u_3} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_1} [AddCommMonoid P] (f : AddSubmonoid.LocalizationMap S N) {T : AddSubmonoid P} {k : P ≃+ M} (H : AddSubmonoid.map (AddEquiv.toAddMonoidHom k) T = S) (y : { x // x ∈ T }) : IsAddUnit (↑(AddMonoidHom.comp (AddSubmonoid.LocalizationMap.toMap f) (AddEquiv.toAddMonoidHom k)) ↑y)

theorem AddSubmonoid.LocalizationMap.ofAddEquivOfDom.proof_3 {M : Type u_3} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_1} [AddCommMonoid P] (f : AddSubmonoid.LocalizationMap S N) {T : AddSubmonoid P} {k : P ≃+ M} (H : AddSubmonoid.map (AddEquiv.toAddMonoidHom k) T = S) (z : N) : ∃ x, z + ↑(AddMonoidHom.comp (AddSubmonoid.LocalizationMap.toMap f) (AddEquiv.toAddMonoidHom k)) ↑x.snd = ↑(AddMonoidHom.comp (AddSubmonoid.LocalizationMap.toMap f) (AddEquiv.toAddMonoidHom k)) x.fst

abbrev AddSubmonoid.LocalizationMap.ofAddEquivOfDom.match_6 {P : Type u_1} [AddCommMonoid P] {T : AddSubmonoid P} (x : P) (y : P) (motive : (∃ c, ↑c + x = ↑c + y) → Prop) : (x : ∃ c, ↑c + x = ↑c + y) → ((c : { x // x ∈ T }) → (hc : ↑c + x = ↑c + y) → motive (_ : ∃ c, ↑c + x = ↑c + y)) → motive x

Equations

• AddSubmonoid.LocalizationMap.ofAddEquivOfDom.match_6 x y motive x h_1 = Exists.casesOn x fun w h => h_1 w h

abbrev AddSubmonoid.LocalizationMap.ofAddEquivOfDom.match_4 {M : Type u_2} [AddCommMonoid M] {S : AddSubmonoid M} {P : Type u_1} [AddCommMonoid P] {k : P ≃+ M} (c : { x // x ∈ S }) (motive : (∃ a, ↑k.toEquiv a = ↑c) → Prop) : (x : ∃ a, ↑k.toEquiv a = ↑c) → ((d : P) → (hd : ↑k.toEquiv d = ↑c) → motive (_ : ∃ a, ↑k.toEquiv a = ↑c)) → motive x

Equations

• AddSubmonoid.LocalizationMap.ofAddEquivOfDom.match_4 c motive x h_1 = Exists.casesOn x fun w h => h_1 w h

abbrev AddSubmonoid.LocalizationMap.ofAddEquivOfDom.match_3 {M : Type u_2} [AddCommMonoid M] {S : AddSubmonoid M} {P : Type u_1} [AddCommMonoid P] {k : P ≃+ M} (x : M × { x // x ∈ S }) (motive : (∃ a, ↑k.toEquiv a = x.fst) → Prop) : (x : ∃ a, ↑k.toEquiv a = x.fst) → ((v : P) → (hv : ↑k.toEquiv v = x.fst) → motive (_ : ∃ a, ↑k.toEquiv a = x.fst)) → motive x

Equations

• AddSubmonoid.LocalizationMap.ofAddEquivOfDom.match_3 x motive x h_1 = Exists.casesOn x fun w h => h_1 w h

abbrev AddSubmonoid.LocalizationMap.ofAddEquivOfDom.match_1 {M : Type u_2} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_1} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : AddSubmonoid.LocalizationMap S N) {T : AddSubmonoid P} {k : P ≃+ M} (H : AddSubmonoid.map (AddEquiv.toAddMonoidHom k) T = S) (y : { x // x ∈ T }) (motive : IsAddUnit (↑(AddSubmonoid.LocalizationMap.toMap f) ↑{ val := ↑k ↑y, property := (_ : ↑k ↑y ∈ S) }) → Prop) : (x : IsAddUnit (↑(AddSubmonoid.LocalizationMap.toMap f) ↑{ val := ↑k ↑y, property := (_ : ↑k ↑y ∈ S) })) → ((z : AddUnits ((fun x => N) ↑{ val := ↑k ↑y, property := (_ : ↑k ↑y ∈ S) })) → (hz : ↑z = ↑(AddSubmonoid.LocalizationMap.toMap f) ↑{ val := ↑k ↑y, property := (_ : ↑k ↑y ∈ S) }) → motive (_ : ∃ u, ↑u = ↑(AddSubmonoid.LocalizationMap.toMap f) ↑{ val := ↑k ↑y, property := (_ : ↑k ↑y ∈ S) })) → motive x

Equations

• AddSubmonoid.LocalizationMap.ofAddEquivOfDom.match_1 f H y motive x h_1 = Exists.casesOn x fun w h => h_1 w h

theorem AddSubmonoid.LocalizationMap.ofAddEquivOfDom.proof_4 {M : Type u_2} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_1} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : AddSubmonoid.LocalizationMap S N) {T : AddSubmonoid P} {k : P ≃+ M} (H : AddSubmonoid.map (AddEquiv.toAddMonoidHom k) T = S) (x : P) (y : P) : ↑(AddSubmonoid.LocalizationMap.toMap f) (↑(AddEquiv.toAddMonoidHom k) x) = ↑(AddSubmonoid.LocalizationMap.toMap f) (↑(AddEquiv.toAddMonoidHom k) y) ↔ ∃ c, ↑c + x = ↑c + y

abbrev AddSubmonoid.LocalizationMap.ofAddEquivOfDom.match_2 {M : Type u_2} [AddCommMonoid M] {S : AddSubmonoid M} {P : Type u_1} [AddCommMonoid P] {k : P ≃+ M} (x : M × { x // x ∈ S }) (motive : (∃ a, ↑k.toEquiv a = ↑x.snd) → Prop) : (x : ∃ a, ↑k.toEquiv a = ↑x.snd) → ((w : P) → (hw : ↑k.toEquiv w = ↑x.snd) → motive (_ : ∃ a, ↑k.toEquiv a = ↑x.snd)) → motive x

Equations

• AddSubmonoid.LocalizationMap.ofAddEquivOfDom.match_2 x motive x h_1 = Exists.casesOn x fun w h => h_1 w h

abbrev AddSubmonoid.LocalizationMap.ofAddEquivOfDom.match_5 {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {P : Type u_2} [AddCommMonoid P] {k : P ≃+ M} (x : P) (y : P) (motive : (∃ c, ↑c + ↑(AddEquiv.toAddMonoidHom k) x = ↑c + ↑(AddEquiv.toAddMonoidHom k) y) → Prop) : (x : ∃ c, ↑c + ↑(AddEquiv.toAddMonoidHom k) x = ↑c + ↑(AddEquiv.toAddMonoidHom k) y) → ((c : { x // x ∈ S }) → (hc : ↑c + ↑(AddEquiv.toAddMonoidHom k) x = ↑c + ↑(AddEquiv.toAddMonoidHom k) y) → motive (_ : ∃ c, ↑c + ↑(AddEquiv.toAddMonoidHom k) x = ↑c + ↑(AddEquiv.toAddMonoidHom k) y)) → motive x

Equations

• AddSubmonoid.LocalizationMap.ofAddEquivOfDom.match_5 x y motive x h_1 = Exists.casesOn x fun w h => h_1 w h

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 : AddSubmonoid.LocalizationMap S N) {T : AddSubmonoid P} {k : P ≃+ M} (H : AddSubmonoid.map (AddEquiv.toAddMonoidHom k) T = S) : AddSubmonoid.LocalizationMap T 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

• One or more equations did not get rendered due to their size.

theorem AddSubmonoid.LocalizationMap.ofAddEquivOfDom.proof_1 {M : Type u_2} [AddCommMonoid M] {S : AddSubmonoid M} {P : Type u_1} [AddCommMonoid P] {T : AddSubmonoid P} {k : P ≃+ M} (H : AddSubmonoid.map (AddEquiv.toAddMonoidHom k) T = S) : AddSubmonoid.comap (AddEquiv.toAddMonoidHom k) S = T

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 : Submonoid.LocalizationMap S N) {T : Submonoid P} {k : P ≃* M} (H : Submonoid.map (MulEquiv.toMonoidHom k) T = S) : Submonoid.LocalizationMap T 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

• One or more equations did not get rendered due to their size.

@[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 : AddSubmonoid.LocalizationMap S N) {T : AddSubmonoid P} {k : P ≃+ M} (H : AddSubmonoid.map (AddEquiv.toAddMonoidHom k) T = S) (x : P) : ↑(AddSubmonoid.LocalizationMap.toMap (AddSubmonoid.LocalizationMap.ofAddEquivOfDom f H)) x = ↑(AddSubmonoid.LocalizationMap.toMap f) (↑k x)

@[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 : Submonoid.LocalizationMap S N) {T : Submonoid P} {k : P ≃* M} (H : Submonoid.map (MulEquiv.toMonoidHom k) T = S) (x : P) : ↑(Submonoid.LocalizationMap.toMap (Submonoid.LocalizationMap.ofMulEquivOfDom f H)) x = ↑(Submonoid.LocalizationMap.toMap f) (↑k x)

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 : AddSubmonoid.LocalizationMap S N) {T : AddSubmonoid P} {k : P ≃+ M} (H : AddSubmonoid.map (AddEquiv.toAddMonoidHom k) T = S) : AddSubmonoid.LocalizationMap.toMap (AddSubmonoid.LocalizationMap.ofAddEquivOfDom f H) = AddMonoidHom.comp (AddSubmonoid.LocalizationMap.toMap f) (AddEquiv.toAddMonoidHom k)

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 : Submonoid.LocalizationMap S N) {T : Submonoid P} {k : P ≃* M} (H : Submonoid.map (MulEquiv.toMonoidHom k) T = S) : Submonoid.LocalizationMap.toMap (Submonoid.LocalizationMap.ofMulEquivOfDom f H) = MonoidHom.comp (Submonoid.LocalizationMap.toMap f) (MulEquiv.toMonoidHom k)

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 : AddSubmonoid.LocalizationMap S N) {T : AddSubmonoid P} {k : P ≃+ M} (H : AddSubmonoid.map (AddEquiv.toAddMonoidHom k) T = S) (x : M) : ↑(AddSubmonoid.LocalizationMap.toMap (AddSubmonoid.LocalizationMap.ofAddEquivOfDom f H)) (↑(AddEquiv.symm k) x) = ↑(AddSubmonoid.LocalizationMap.toMap f) x

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 : Submonoid.LocalizationMap S N) {T : Submonoid P} {k : P ≃* M} (H : Submonoid.map (MulEquiv.toMonoidHom k) T = S) (x : M) : ↑(Submonoid.LocalizationMap.toMap (Submonoid.LocalizationMap.ofMulEquivOfDom f H)) (↑(MulEquiv.symm k) x) = ↑(Submonoid.LocalizationMap.toMap f) 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 : AddSubmonoid.LocalizationMap S N) {T : AddSubmonoid P} {k : M ≃+ P} (H : AddSubmonoid.map (AddEquiv.toAddMonoidHom (AddEquiv.symm k)) T = S) (x : M) : ↑(AddSubmonoid.LocalizationMap.toMap (AddSubmonoid.LocalizationMap.ofAddEquivOfDom f H)) (↑k x) = ↑(AddSubmonoid.LocalizationMap.toMap f) 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 : Submonoid.LocalizationMap S N) {T : Submonoid P} {k : M ≃* P} (H : Submonoid.map (MulEquiv.toMonoidHom (MulEquiv.symm k)) T = S) (x : M) : ↑(Submonoid.LocalizationMap.toMap (Submonoid.LocalizationMap.ofMulEquivOfDom f H)) (↑k x) = ↑(Submonoid.LocalizationMap.toMap f) x

@[simp]

theorem AddSubmonoid.LocalizationMap.ofAddEquivOfDom_id {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) : AddSubmonoid.LocalizationMap.ofAddEquivOfDom f (_ : AddSubmonoid.map (AddEquiv.toAddMonoidHom (AddEquiv.refl M)) S = S) = f

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

abbrev AddSubmonoid.LocalizationMap.ofAddEquivOfDom_id.match_1 {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} (x : M) (motive : x ∈ AddSubmonoid.map (AddEquiv.toAddMonoidHom (AddEquiv.refl M)) S → Prop) : (x : x ∈ AddSubmonoid.map (AddEquiv.toAddMonoidHom (AddEquiv.refl M)) S) → ((w : M) → (hy : w ∈ ↑S) → (h : ↑(AddEquiv.toAddMonoidHom (AddEquiv.refl M)) w = x) → motive (_ : ∃ a, a ∈ ↑S ∧ ↑(AddEquiv.toAddMonoidHom (AddEquiv.refl M)) a = x)) → motive x

Equations

• AddSubmonoid.LocalizationMap.ofAddEquivOfDom_id.match_1 x motive x h_1 = Exists.casesOn x fun w h => And.casesOn h fun left right => h_1 w left right

@[simp]

theorem Submonoid.LocalizationMap.ofMulEquivOfDom_id {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) : Submonoid.LocalizationMap.ofMulEquivOfDom f (_ : Submonoid.map (MulEquiv.toMonoidHom (MulEquiv.refl M)) S = S) = f

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

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 : AddSubmonoid.LocalizationMap S N) {T : AddSubmonoid P} {Q : Type u_4} [AddCommMonoid Q] (k : AddSubmonoid.LocalizationMap T Q) {j : M ≃+ P} (H : AddSubmonoid.map (AddEquiv.toAddMonoidHom j) 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

• AddSubmonoid.LocalizationMap.addEquivOfAddEquiv f k H = AddSubmonoid.LocalizationMap.addEquivOfLocalizations f (AddSubmonoid.LocalizationMap.ofAddEquivOfDom k H)

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 : Submonoid.LocalizationMap S N) {T : Submonoid P} {Q : Type u_4} [CommMonoid Q] (k : Submonoid.LocalizationMap T Q) {j : M ≃* P} (H : Submonoid.map (MulEquiv.toMonoidHom j) 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

• Submonoid.LocalizationMap.mulEquivOfMulEquiv f k H = Submonoid.LocalizationMap.mulEquivOfLocalizations f (Submonoid.LocalizationMap.ofMulEquivOfDom k H)

@[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 : AddSubmonoid.LocalizationMap S N) {T : AddSubmonoid P} {Q : Type u_4} [AddCommMonoid Q] {k : AddSubmonoid.LocalizationMap T Q} {j : M ≃+ P} (H : AddSubmonoid.map (AddEquiv.toAddMonoidHom j) S = T) (x : N) : ↑(AddSubmonoid.LocalizationMap.addEquivOfAddEquiv f k H) x = ↑(AddSubmonoid.LocalizationMap.map f (_ : ∀ (y : { x // x ∈ S }), ↑(AddEquiv.toAddMonoidHom j) ↑y ∈ T) k) x

@[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 : Submonoid.LocalizationMap S N) {T : Submonoid P} {Q : Type u_4} [CommMonoid Q] {k : Submonoid.LocalizationMap T Q} {j : M ≃* P} (H : Submonoid.map (MulEquiv.toMonoidHom j) S = T) (x : N) : ↑(Submonoid.LocalizationMap.mulEquivOfMulEquiv f k H) x = ↑(Submonoid.LocalizationMap.map f (_ : ∀ (y : { x // x ∈ S }), ↑(MulEquiv.toMonoidHom j) ↑y ∈ T) k) x

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 : AddSubmonoid.LocalizationMap S N) {T : AddSubmonoid P} {Q : Type u_4} [AddCommMonoid Q] {k : AddSubmonoid.LocalizationMap T Q} {j : M ≃+ P} (H : AddSubmonoid.map (AddEquiv.toAddMonoidHom j) S = T) : AddEquiv.toAddMonoidHom (AddSubmonoid.LocalizationMap.addEquivOfAddEquiv f k H) = AddSubmonoid.LocalizationMap.map f (_ : ∀ (y : { x // x ∈ S }), ↑(AddEquiv.toAddMonoidHom j) ↑y ∈ T) k

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 : Submonoid.LocalizationMap S N) {T : Submonoid P} {Q : Type u_4} [CommMonoid Q] {k : Submonoid.LocalizationMap T Q} {j : M ≃* P} (H : Submonoid.map (MulEquiv.toMonoidHom j) S = T) : MulEquiv.toMonoidHom (Submonoid.LocalizationMap.mulEquivOfMulEquiv f k H) = Submonoid.LocalizationMap.map f (_ : ∀ (y : { x // x ∈ S }), ↑(MulEquiv.toMonoidHom j) ↑y ∈ T) k

@[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 : AddSubmonoid.LocalizationMap S N) {T : AddSubmonoid P} {Q : Type u_4} [AddCommMonoid Q] {k : AddSubmonoid.LocalizationMap T Q} {j : M ≃+ P} (H : AddSubmonoid.map (AddEquiv.toAddMonoidHom j) S = T) (x : M) : ↑(AddSubmonoid.LocalizationMap.addEquivOfAddEquiv f k H) (↑(AddSubmonoid.LocalizationMap.toMap f) x) = ↑(AddSubmonoid.LocalizationMap.toMap k) (↑j x)

@[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 : Submonoid.LocalizationMap S N) {T : Submonoid P} {Q : Type u_4} [CommMonoid Q] {k : Submonoid.LocalizationMap T Q} {j : M ≃* P} (H : Submonoid.map (MulEquiv.toMonoidHom j) S = T) (x : M) : ↑(Submonoid.LocalizationMap.mulEquivOfMulEquiv f k H) (↑(Submonoid.LocalizationMap.toMap f) x) = ↑(Submonoid.LocalizationMap.toMap k) (↑j x)

@[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 : AddSubmonoid.LocalizationMap S N) {T : AddSubmonoid P} {Q : Type u_4} [AddCommMonoid Q] {k : AddSubmonoid.LocalizationMap T Q} {j : M ≃+ P} (H : AddSubmonoid.map (AddEquiv.toAddMonoidHom j) S = T) (x : M) (y : { x // x ∈ S }) : ↑(AddSubmonoid.LocalizationMap.addEquivOfAddEquiv f k H) (AddSubmonoid.LocalizationMap.mk' f x y) = AddSubmonoid.LocalizationMap.mk' k (↑j x) { val := ↑j ↑y, property := (_ : ↑j ↑y ∈ T) }

@[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 : Submonoid.LocalizationMap S N) {T : Submonoid P} {Q : Type u_4} [CommMonoid Q] {k : Submonoid.LocalizationMap T Q} {j : M ≃* P} (H : Submonoid.map (MulEquiv.toMonoidHom j) S = T) (x : M) (y : { x // x ∈ S }) : ↑(Submonoid.LocalizationMap.mulEquivOfMulEquiv f k H) (Submonoid.LocalizationMap.mk' f x y) = Submonoid.LocalizationMap.mk' k (↑j x) { val := ↑j ↑y, property := (_ : ↑j ↑y ∈ T) }

@[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 : AddSubmonoid.LocalizationMap S N) {T : AddSubmonoid P} {Q : Type u_4} [AddCommMonoid Q] {k : AddSubmonoid.LocalizationMap T Q} {j : M ≃+ P} (H : AddSubmonoid.map (AddEquiv.toAddMonoidHom j) S = T) (x : M) : ↑(AddSubmonoid.LocalizationMap.toMap (AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations f (AddSubmonoid.LocalizationMap.addEquivOfAddEquiv f k H))) x = ↑(AddSubmonoid.LocalizationMap.toMap k) (↑j x)

@[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 : Submonoid.LocalizationMap S N) {T : Submonoid P} {Q : Type u_4} [CommMonoid Q] {k : Submonoid.LocalizationMap T Q} {j : M ≃* P} (H : Submonoid.map (MulEquiv.toMonoidHom j) S = T) (x : M) : ↑(Submonoid.LocalizationMap.toMap (Submonoid.LocalizationMap.ofMulEquivOfLocalizations f (Submonoid.LocalizationMap.mulEquivOfMulEquiv f k H))) x = ↑(Submonoid.LocalizationMap.toMap k) (↑j x)

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 : AddSubmonoid.LocalizationMap S N) {T : AddSubmonoid P} {Q : Type u_4} [AddCommMonoid Q] {k : AddSubmonoid.LocalizationMap T Q} {j : M ≃+ P} (H : AddSubmonoid.map (AddEquiv.toAddMonoidHom j) S = T) : AddSubmonoid.LocalizationMap.toMap (AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations f (AddSubmonoid.LocalizationMap.addEquivOfAddEquiv f k H)) = AddMonoidHom.comp (AddSubmonoid.LocalizationMap.toMap k) (AddEquiv.toAddMonoidHom j)

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 : Submonoid.LocalizationMap S N) {T : Submonoid P} {Q : Type u_4} [CommMonoid Q] {k : Submonoid.LocalizationMap T Q} {j : M ≃* P} (H : Submonoid.map (MulEquiv.toMonoidHom j) S = T) : Submonoid.LocalizationMap.toMap (Submonoid.LocalizationMap.ofMulEquivOfLocalizations f (Submonoid.LocalizationMap.mulEquivOfMulEquiv f k H)) = MonoidHom.comp (Submonoid.LocalizationMap.toMap k) (MulEquiv.toMonoidHom j)

theorem AddLocalization.addMonoidOf.proof_3 {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) (z : AddLocalization S) : ∃ x, z + ZeroHom.toFun ↑{ toZeroHom := { toFun := fun x => AddLocalization.mk x 0, map_zero' := (_ : AddLocalization.mk 0 0 = 0) }, map_add' := (_ : ∀ (x y : M), ZeroHom.toFun { toFun := fun x => AddLocalization.mk x 0, map_zero' := (_ : AddLocalization.mk 0 0 = 0) } (x + y) = ZeroHom.toFun { toFun := fun x => AddLocalization.mk x 0, map_zero' := (_ : AddLocalization.mk 0 0 = 0) } x + ZeroHom.toFun { toFun := fun x => AddLocalization.mk x 0, map_zero' := (_ : AddLocalization.mk 0 0 = 0) } y) } ↑x.snd = ZeroHom.toFun (↑{ toZeroHom := { toFun := fun x => AddLocalization.mk x 0, map_zero' := (_ : AddLocalization.mk 0 0 = 0) }, map_add' := (_ : ∀ (x y : M), ZeroHom.toFun { toFun := fun x => AddLocalization.mk x 0, map_zero' := (_ : AddLocalization.mk 0 0 = 0) } (x + y) = ZeroHom.toFun { toFun := fun x => AddLocalization.mk x 0, map_zero' := (_ : AddLocalization.mk 0 0 = 0) } x + ZeroHom.toFun { toFun := fun x => AddLocalization.mk x 0, map_zero' := (_ : AddLocalization.mk 0 0 = 0) } y) }) x.fst

theorem AddLocalization.addMonoidOf.proof_2 {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) (y : { x // x ∈ S }) : IsAddUnit (ZeroHom.toFun ↑{ toZeroHom := { toFun := fun x => AddLocalization.mk x 0, map_zero' := (_ : AddLocalization.mk 0 0 = 0) }, map_add' := (_ : ∀ (x y : M), ZeroHom.toFun { toFun := fun x => AddLocalization.mk x 0, map_zero' := (_ : AddLocalization.mk 0 0 = 0) } (x + y) = ZeroHom.toFun { toFun := fun x => AddLocalization.mk x 0, map_zero' := (_ : AddLocalization.mk 0 0 = 0) } x + ZeroHom.toFun { toFun := fun x => AddLocalization.mk x 0, map_zero' := (_ : AddLocalization.mk 0 0 = 0) } y) } ↑y)

theorem AddLocalization.addMonoidOf.proof_1 {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) (x : M) (y : M) : ZeroHom.toFun { toFun := fun x => AddLocalization.mk x 0, map_zero' := (_ : AddLocalization.mk 0 0 = 0) } (x + y) = ZeroHom.toFun { toFun := fun x => AddLocalization.mk x 0, map_zero' := (_ : AddLocalization.mk 0 0 = 0) } x + ZeroHom.toFun { toFun := fun x => AddLocalization.mk x 0, map_zero' := (_ : AddLocalization.mk 0 0 = 0) } y

theorem AddLocalization.addMonoidOf.proof_4 {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) (x : M) (y : M) : AddLocalization.mk x 0 = AddLocalization.mk y 0 ↔ ∃ c, ↑c + x = ↑c + y

def AddLocalization.addMonoidOf {M : Type u_1} [AddCommMonoid M] (S : AddSubmonoid M) : AddSubmonoid.LocalizationMap S (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

• One or more equations did not get rendered due to their size.

def Localization.monoidOf {M : Type u_1} [CommMonoid M] (S : Submonoid M) : Submonoid.LocalizationMap S (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

• One or more equations did not get rendered due to their size.

theorem AddLocalization.mk_zero_eq_addMonoidOf_mk {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} (x : M) : AddLocalization.mk x 0 = ↑(AddSubmonoid.LocalizationMap.toMap (AddLocalization.addMonoidOf S)) x

theorem Localization.mk_one_eq_monoidOf_mk {M : Type u_1} [CommMonoid M] {S : Submonoid M} (x : M) : Localization.mk x 1 = ↑(Submonoid.LocalizationMap.toMap (Localization.monoidOf S)) x

theorem AddLocalization.mk_eq_addMonoidOf_mk'_apply {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} (x : M) (y : { x // x ∈ S }) : AddLocalization.mk x y = AddSubmonoid.LocalizationMap.mk' (AddLocalization.addMonoidOf S) x y

theorem Localization.mk_eq_monoidOf_mk'_apply {M : Type u_1} [CommMonoid M] {S : Submonoid M} (x : M) (y : { x // x ∈ S }) : Localization.mk x y = Submonoid.LocalizationMap.mk' (Localization.monoidOf S) x y

@[simp]

theorem AddLocalization.mk_eq_addMonoidOf_mk' {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} : AddLocalization.mk = AddSubmonoid.LocalizationMap.mk' (AddLocalization.addMonoidOf S)

@[simp]

theorem Localization.mk_eq_monoidOf_mk' {M : Type u_1} [CommMonoid M] {S : Submonoid M} : Localization.mk = Submonoid.LocalizationMap.mk' (Localization.monoidOf S)

@[simp]

theorem AddLocalization.liftOn_mk' {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u} (f : M → { x // x ∈ S } → p) (H : ∀ {a c : M} {b d : { x // x ∈ S }}, ↑(AddLocalization.r S) (a, b) (c, d) → f a b = f c d) (a : M) (b : { x // x ∈ S }) : AddLocalization.liftOn (AddSubmonoid.LocalizationMap.mk' (AddLocalization.addMonoidOf S) a b) f H = f a b

@[simp]

theorem Localization.liftOn_mk' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {p : Sort u} (f : M → { x // x ∈ S } → p) (H : ∀ {a c : M} {b d : { x // x ∈ S }}, ↑(Localization.r S) (a, b) (c, d) → f a b = f c d) (a : M) (b : { x // x ∈ S }) : Localization.liftOn (Submonoid.LocalizationMap.mk' (Localization.monoidOf S) a b) f H = f a b

@[simp]

theorem AddLocalization.liftOn₂_mk' {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u_4} (f : M → { x // x ∈ S } → M → { x // x ∈ S } → p) (H : ∀ {a a' : M} {b b' : { x // x ∈ S }} {c c' : M} {d d' : { x // x ∈ 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 : { x // x ∈ S }) (d : { x // x ∈ S }) : AddLocalization.liftOn₂ (AddSubmonoid.LocalizationMap.mk' (AddLocalization.addMonoidOf S) a b) (AddSubmonoid.LocalizationMap.mk' (AddLocalization.addMonoidOf S) c d) f H = f a b c d

@[simp]

theorem Localization.liftOn₂_mk' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {p : Sort u_4} (f : M → { x // x ∈ S } → M → { x // x ∈ S } → p) (H : ∀ {a a' : M} {b b' : { x // x ∈ S }} {c c' : M} {d d' : { x // x ∈ 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 : { x // x ∈ S }) (d : { x // x ∈ S }) : Localization.liftOn₂ (Submonoid.LocalizationMap.mk' (Localization.monoidOf S) a b) (Submonoid.LocalizationMap.mk' (Localization.monoidOf S) c d) f H = f a b c d

noncomputable def AddLocalization.addEquivOfQuotient {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] (f : AddSubmonoid.LocalizationMap S N) : AddLocalization S ≃+ N

Given a Localization map f : M →+ N for a Submonoid S, we get an isomorphism between the Localization of M at S as a quotient type and N.

Equations

• AddLocalization.addEquivOfQuotient f = AddSubmonoid.LocalizationMap.addEquivOfLocalizations (AddLocalization.addMonoidOf S) f

noncomputable def Localization.mulEquivOfQuotient {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : Submonoid.LocalizationMap S N) : Localization S ≃* N

Given a Localization map f : M →* N for a Submonoid S, we get an isomorphism between the Localization of M at S as a quotient type and N.

Equations

• Localization.mulEquivOfQuotient f = Submonoid.LocalizationMap.mulEquivOfLocalizations (Localization.monoidOf S) f

@[simp]

theorem AddLocalization.addEquivOfQuotient_apply {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : AddSubmonoid.LocalizationMap S N} (x : AddLocalization S) : ↑(AddLocalization.addEquivOfQuotient f) x = ↑(AddSubmonoid.LocalizationMap.lift (AddLocalization.addMonoidOf S) (_ : ∀ (y : { x // x ∈ S }), IsAddUnit (↑(AddSubmonoid.LocalizationMap.toMap f) ↑y))) x

@[simp]

theorem Localization.mulEquivOfQuotient_apply {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : Submonoid.LocalizationMap S N} (x : Localization S) : ↑(Localization.mulEquivOfQuotient f) x = ↑(Submonoid.LocalizationMap.lift (Localization.monoidOf S) (_ : ∀ (y : { x // x ∈ S }), IsUnit (↑(Submonoid.LocalizationMap.toMap f) ↑y))) x

@[simp]

theorem AddLocalization.addEquivOfQuotient_mk' {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : AddSubmonoid.LocalizationMap S N} (x : M) (y : { x // x ∈ S }) : ↑(AddLocalization.addEquivOfQuotient f) (AddSubmonoid.LocalizationMap.mk' (AddLocalization.addMonoidOf S) x y) = AddSubmonoid.LocalizationMap.mk' f x y

@[simp]

theorem Localization.mulEquivOfQuotient_mk' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : Submonoid.LocalizationMap S N} (x : M) (y : { x // x ∈ S }) : ↑(Localization.mulEquivOfQuotient f) (Submonoid.LocalizationMap.mk' (Localization.monoidOf S) x y) = Submonoid.LocalizationMap.mk' f x y

theorem AddLocalization.addEquivOfQuotient_mk {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : AddSubmonoid.LocalizationMap S N} (x : M) (y : { x // x ∈ S }) : ↑(AddLocalization.addEquivOfQuotient f) (AddLocalization.mk x y) = AddSubmonoid.LocalizationMap.mk' f x y

theorem Localization.mulEquivOfQuotient_mk {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : Submonoid.LocalizationMap S N} (x : M) (y : { x // x ∈ S }) : ↑(Localization.mulEquivOfQuotient f) (Localization.mk x y) = Submonoid.LocalizationMap.mk' f x y

theorem AddLocalization.addEquivOfQuotient_addMonoidOf {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : AddSubmonoid.LocalizationMap S N} (x : M) : ↑(AddLocalization.addEquivOfQuotient f) (↑(AddSubmonoid.LocalizationMap.toMap (AddLocalization.addMonoidOf S)) x) = ↑(AddSubmonoid.LocalizationMap.toMap f) x

theorem Localization.mulEquivOfQuotient_monoidOf {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : Submonoid.LocalizationMap S N} (x : M) : ↑(Localization.mulEquivOfQuotient f) (↑(Submonoid.LocalizationMap.toMap (Localization.monoidOf S)) x) = ↑(Submonoid.LocalizationMap.toMap f) x

@[simp]

theorem AddLocalization.addEquivOfQuotient_symm_mk' {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : AddSubmonoid.LocalizationMap S N} (x : M) (y : { x // x ∈ S }) : ↑(AddEquiv.symm (AddLocalization.addEquivOfQuotient f)) (AddSubmonoid.LocalizationMap.mk' f x y) = AddSubmonoid.LocalizationMap.mk' (AddLocalization.addMonoidOf S) x y

@[simp]

theorem Localization.mulEquivOfQuotient_symm_mk' {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : Submonoid.LocalizationMap S N} (x : M) (y : { x // x ∈ S }) : ↑(MulEquiv.symm (Localization.mulEquivOfQuotient f)) (Submonoid.LocalizationMap.mk' f x y) = Submonoid.LocalizationMap.mk' (Localization.monoidOf S) x y

theorem AddLocalization.addEquivOfQuotient_symm_mk {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : AddSubmonoid.LocalizationMap S N} (x : M) (y : { x // x ∈ S }) : ↑(AddEquiv.symm (AddLocalization.addEquivOfQuotient f)) (AddSubmonoid.LocalizationMap.mk' f x y) = AddLocalization.mk x y

theorem Localization.mulEquivOfQuotient_symm_mk {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : Submonoid.LocalizationMap S N} (x : M) (y : { x // x ∈ S }) : ↑(MulEquiv.symm (Localization.mulEquivOfQuotient f)) (Submonoid.LocalizationMap.mk' f x y) = Localization.mk x y

@[simp]

theorem AddLocalization.addEquivOfQuotient_symm_addMonoidOf {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : AddSubmonoid.LocalizationMap S N} (x : M) : ↑(AddEquiv.symm (AddLocalization.addEquivOfQuotient f)) (↑(AddSubmonoid.LocalizationMap.toMap f) x) = ↑(AddSubmonoid.LocalizationMap.toMap (AddLocalization.addMonoidOf S)) x

@[simp]

theorem Localization.mulEquivOfQuotient_symm_monoidOf {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : Submonoid.LocalizationMap S N} (x : M) : ↑(MulEquiv.symm (Localization.mulEquivOfQuotient f)) (↑(Submonoid.LocalizationMap.toMap f) x) = ↑(Submonoid.LocalizationMap.toMap (Localization.monoidOf S)) x

@[reducible]

def AddLocalization.Away {M : Type u_1} [AddCommMonoid M] (x : M) : Type u_1

Given x : M, the Localization of M at the Submonoid generated by x, as a quotient.

Equations

• AddLocalization.Away x = AddLocalization (AddSubmonoid.multiples x)

@[reducible]

def Localization.Away {M : Type u_1} [CommMonoid M] (x : M) : Type u_1

Given x : M, the Localization of M at the Submonoid generated by x, as a quotient.

Equations

• Localization.Away x = Localization (Submonoid.powers x)

def AddLocalization.Away.negSelf {M : Type u_1} [AddCommMonoid M] (x : M) : AddLocalization.Away x

Given x : M, negSelf is -x in the Localization (as a quotient type) of M at the Submonoid generated by x.

Equations

• AddLocalization.Away.negSelf x = AddLocalization.mk 0 { val := x, property := (_ : x ∈ AddSubmonoid.multiples x) }

theorem AddLocalization.Away.negSelf.proof_1 {M : Type u_1} [AddCommMonoid M] (x : M) : x ∈ AddSubmonoid.multiples x

def Localization.Away.invSelf {M : Type u_1} [CommMonoid M] (x : M) : Localization.Away x

Given x : M, invSelf is x⁻¹ in the Localization (as a quotient type) of M at the Submonoid generated by x.

Equations

• Localization.Away.invSelf x = Localization.mk 1 { val := x, property := (_ : x ∈ Submonoid.powers x) }

@[reducible]

def AddLocalization.Away.addMonoidOf {M : Type u_1} [AddCommMonoid M] (x : M) : AddSubmonoid.LocalizationMap.AwayMap x (AddLocalization.Away x)

Given x : M, the natural hom sending y : M, M an AddCommMonoid, to the equivalence class of (y, 0) in the Localization of M at the Submonoid generated by x.

Equations

• AddLocalization.Away.addMonoidOf x = AddLocalization.addMonoidOf (AddSubmonoid.multiples x)

@[reducible]

def Localization.Away.monoidOf {M : Type u_1} [CommMonoid M] (x : M) : Submonoid.LocalizationMap.AwayMap x (Localization.Away x)

Given x : M, the natural hom sending y : M, M a CommMonoid, to the equivalence class of (y, 1) in the Localization of M at the Submonoid generated by x.

Equations

• Localization.Away.monoidOf x = Localization.monoidOf (Submonoid.powers x)

theorem AddLocalization.Away.mk_eq_addMonoidOf_mk' {M : Type u_1} [AddCommMonoid M] (x : M) : AddLocalization.mk = AddSubmonoid.LocalizationMap.mk' (AddLocalization.Away.addMonoidOf x)

theorem Localization.Away.mk_eq_monoidOf_mk' {M : Type u_1} [CommMonoid M] (x : M) : Localization.mk = Submonoid.LocalizationMap.mk' (Localization.Away.monoidOf x)

noncomputable def AddLocalization.Away.addEquivOfQuotient {M : Type u_1} [AddCommMonoid M] {N : Type u_2} [AddCommMonoid N] (x : M) (f : AddSubmonoid.LocalizationMap.AwayMap x N) : AddLocalization.Away x ≃+ N

Given x : M and a Localization map f : M →+ N away from x, we get an isomorphism between the Localization of M at the Submonoid generated by x as a quotient type and N.

Equations

• AddLocalization.Away.addEquivOfQuotient x f = AddLocalization.addEquivOfQuotient f

noncomputable def Localization.Away.mulEquivOfQuotient {M : Type u_1} [CommMonoid M] {N : Type u_2} [CommMonoid N] (x : M) (f : Submonoid.LocalizationMap.AwayMap x N) : Localization.Away x ≃* N

Given x : M and a Localization map f : M →* N away from x, we get an isomorphism between the Localization of M at the Submonoid generated by x as a quotient type and N.

Equations

• Localization.Away.mulEquivOfQuotient x f = Localization.mulEquivOfQuotient f

structure Submonoid.LocalizationWithZeroMap {M : Type u_1} [CommMonoidWithZero M] (S : Submonoid M) (N : Type u_2) [CommMonoidWithZero N] extends Submonoid.LocalizationMap : Type (max u_1 u_2)

• toFun : M → N
• map_one' : OneHom.toFun (↑s.toMonoidHom) 1 = 1
• map_mul' : ∀ (x y : M), OneHom.toFun (↑s.toMonoidHom) (x * y) = OneHom.toFun (↑s.toMonoidHom) x * OneHom.toFun (↑s.toMonoidHom) y
• map_units' : ∀ (y : { x // x ∈ S }), IsUnit (OneHom.toFun ↑s.toMonoidHom ↑y)
• surj' : ∀ (z : N), ∃ x, z * OneHom.toFun ↑s.toMonoidHom ↑x.snd = OneHom.toFun (↑s.toMonoidHom) x.fst
• eq_iff_exists' : ∀ (x y : M), OneHom.toFun (↑s.toMonoidHom) x = OneHom.toFun (↑s.toMonoidHom) y ↔ ∃ c, ↑c * x = ↑c * y
• map_zero' : OneHom.toFun (↑s.toMonoidHom) 0 = 0

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

def Submonoid.LocalizationWithZeroMap.toMonoidWithZeroHom {M : Type u_1} [CommMonoidWithZero M] {S : Submonoid M} {N : Type u_2} [CommMonoidWithZero N] (f : Submonoid.LocalizationWithZeroMap S N) : M →*₀ N

The monoid with zero hom underlying a LocalizationMap.

Equations

• One or more equations did not get rendered due to their size.

theorem Localization.zero_def {M : Type u_4} [CommMonoidWithZero M] (S : Submonoid M) : Localization.zero S = Localization.mk 0 1

@[irreducible]

def Localization.zero {M : Type u_4} [CommMonoidWithZero M] (S : Submonoid M) : Localization S

The zero element in a Localization is defined as (0, 1).

Should not be confused with AddLocalization.zero which is (0, 0).

Equations

• @Localization.zero = Localization.wrapped✝.1

instance Localization.instZeroLocalizationToCommMonoid {M : Type u_1} [CommMonoidWithZero M] (S : Submonoid M) : Zero (Localization S)

Equations

• Localization.instZeroLocalizationToCommMonoid S = { zero := Localization.zero S }

theorem Localization.mk_zero {M : Type u_1} [CommMonoidWithZero M] {S : Submonoid M} (x : { x // x ∈ S }) : Localization.mk 0 x = 0

instance Localization.instCommMonoidWithZeroLocalizationToCommMonoid {M : Type u_1} [CommMonoidWithZero M] {S : Submonoid M} : CommMonoidWithZero (Localization S)

Equations

• Localization.instCommMonoidWithZeroLocalizationToCommMonoid = CommMonoidWithZero.mk (_ : ∀ (x : Localization S), 0 * x = 0) (_ : ∀ (x : Localization S), x * 0 = 0)

theorem Localization.liftOn_zero {M : Type u_1} [CommMonoidWithZero M] {S : Submonoid M} {p : Type u_4} (f : M → { x // x ∈ S } → p) (H : ∀ {a c : M} {b d : { x // x ∈ S }}, ↑(Localization.r S) (a, b) (c, d) → f a b = f c d) : Localization.liftOn 0 f H = f 0 1

@[simp]

theorem Submonoid.LocalizationMap.sec_zero_fst {M : Type u_1} [CommMonoidWithZero M] {S : Submonoid M} {N : Type u_2} [CommMonoidWithZero N] {f : Submonoid.LocalizationMap S N} : ↑(Submonoid.LocalizationMap.toMap f) (Submonoid.LocalizationMap.sec f 0).fst = 0

noncomputable def Submonoid.LocalizationWithZeroMap.lift {M : Type u_1} [CommMonoidWithZero M] {S : Submonoid M} {N : Type u_2} [CommMonoidWithZero N] {P : Type u_3} [CommMonoidWithZero P] (f : Submonoid.LocalizationWithZeroMap S N) (g : M →*₀ P) (hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)) : N →*₀ P

Given a Localization map f : M →*₀ N for a Submonoid S ⊆ M and a map of CommMonoidWithZeros 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

• One or more equations did not get rendered due to their size.

theorem AddLocalization.mk_left_injective {α : Type u_1} [AddCancelCommMonoid α] {s : AddSubmonoid α} (b : { x // x ∈ s }) : Function.Injective fun a => AddLocalization.mk a b

theorem Localization.mk_left_injective {α : Type u_1} [CancelCommMonoid α] {s : Submonoid α} (b : { x // x ∈ s }) : Function.Injective fun a => Localization.mk a b

theorem AddLocalization.mk_eq_mk_iff' {α : Type u_1} [AddCancelCommMonoid α] {s : AddSubmonoid α} {a₁ : α} {b₁ : α} {a₂ : { x // x ∈ s }} {b₂ : { x // x ∈ s }} : AddLocalization.mk a₁ a₂ = AddLocalization.mk b₁ b₂ ↔ ↑b₂ + a₁ = ↑a₂ + b₁

theorem Localization.mk_eq_mk_iff' {α : Type u_1} [CancelCommMonoid α] {s : Submonoid α} {a₁ : α} {b₁ : α} {a₂ : { x // x ∈ s }} {b₂ : { x // x ∈ s }} : Localization.mk a₁ a₂ = Localization.mk b₁ b₂ ↔ ↑b₂ * a₁ = ↑a₂ * b₁

theorem AddLocalization.decidableEq.proof_1 {α : Type u_1} [AddCancelCommMonoid α] {s : AddSubmonoid α} (a : α) (c : α) (b : { x // x ∈ s }) (d : { x // x ∈ s }) : Subsingleton (Decidable (AddLocalization.mk a b = AddLocalization.mk c d))

instance AddLocalization.decidableEq {α : Type u_1} [AddCancelCommMonoid α] {s : AddSubmonoid α} [DecidableEq α] : DecidableEq (AddLocalization s)

Equations

• One or more equations did not get rendered due to their size.

instance Localization.decidableEq {α : Type u_1} [CancelCommMonoid α] {s : Submonoid α} [DecidableEq α] : DecidableEq (Localization s)

Equations

• One or more equations did not get rendered due to their size.

Order

instance AddLocalization.le {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} : LE (AddLocalization s)

Equations

• One or more equations did not get rendered due to their size.

theorem AddLocalization.le.proof_1 {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} (a₁ : α) (b₁ : α) (a₂ : { x // x ∈ s }) (b₂ : { x // x ∈ s }) (c₁ : α) (d₁ : α) (c₂ : { x // x ∈ s }) (d₂ : { x // x ∈ s }) (hab : ↑(AddLocalization.r s) (a₁, a₂) (b₁, b₂)) (hcd : ↑(AddLocalization.r s) (c₁, c₂) (d₁, d₂)) : (fun a₁ a₂ b₁ b₂ => ↑b₂ + a₁ ≤ ↑a₂ + b₁) a₁ a₂ c₁ c₂ = (fun a₁ a₂ b₁ b₂ => ↑b₂ + a₁ ≤ ↑a₂ + b₁) b₁ b₂ d₁ d₂

instance Localization.le {α : Type u_1} [OrderedCancelCommMonoid α] {s : Submonoid α} : LE (Localization s)

Equations

• One or more equations did not get rendered due to their size.

instance AddLocalization.lt {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} : LT (AddLocalization s)

Equations

• One or more equations did not get rendered due to their size.

theorem AddLocalization.lt.proof_1 {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} (a₁ : α) (b₁ : α) (a₂ : { x // x ∈ s }) (b₂ : { x // x ∈ s }) (c₁ : α) (d₁ : α) (c₂ : { x // x ∈ s }) (d₂ : { x // x ∈ s }) (hab : ↑(AddLocalization.r s) (a₁, a₂) (b₁, b₂)) (hcd : ↑(AddLocalization.r s) (c₁, c₂) (d₁, d₂)) : (fun a₁ a₂ b₁ b₂ => ↑b₂ + a₁ < ↑a₂ + b₁) a₁ a₂ c₁ c₂ = (fun a₁ a₂ b₁ b₂ => ↑b₂ + a₁ < ↑a₂ + b₁) b₁ b₂ d₁ d₂

instance Localization.lt {α : Type u_1} [OrderedCancelCommMonoid α] {s : Submonoid α} : LT (Localization s)

Equations

• One or more equations did not get rendered due to their size.

theorem AddLocalization.mk_le_mk {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} {a₁ : α} {b₁ : α} {a₂ : { x // x ∈ s }} {b₂ : { x // x ∈ s }} : AddLocalization.mk a₁ a₂ ≤ AddLocalization.mk b₁ b₂ ↔ ↑b₂ + a₁ ≤ ↑a₂ + b₁

theorem Localization.mk_le_mk {α : Type u_1} [OrderedCancelCommMonoid α] {s : Submonoid α} {a₁ : α} {b₁ : α} {a₂ : { x // x ∈ s }} {b₂ : { x // x ∈ s }} : Localization.mk a₁ a₂ ≤ Localization.mk b₁ b₂ ↔ ↑b₂ * a₁ ≤ ↑a₂ * b₁

theorem AddLocalization.mk_lt_mk {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} {a₁ : α} {b₁ : α} {a₂ : { x // x ∈ s }} {b₂ : { x // x ∈ s }} : AddLocalization.mk a₁ a₂ < AddLocalization.mk b₁ b₂ ↔ ↑b₂ + a₁ < ↑a₂ + b₁

theorem Localization.mk_lt_mk {α : Type u_1} [OrderedCancelCommMonoid α] {s : Submonoid α} {a₁ : α} {b₁ : α} {a₂ : { x // x ∈ s }} {b₂ : { x // x ∈ s }} : Localization.mk a₁ a₂ < Localization.mk b₁ b₂ ↔ ↑b₂ * a₁ < ↑a₂ * b₁

theorem AddLocalization.partialOrder.proof_2 {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} (a : AddLocalization s) (b : AddLocalization s) (c : AddLocalization s) : a ≤ b → b ≤ c → a ≤ c

instance AddLocalization.partialOrder {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} : PartialOrder (AddLocalization s)

Equations

• AddLocalization.partialOrder = PartialOrder.mk (_ : ∀ (a b : AddLocalization s), a ≤ b → b ≤ a → a = b)

theorem AddLocalization.partialOrder.proof_1 {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} (a : AddLocalization s) : a ≤ a

theorem AddLocalization.partialOrder.proof_3 {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} (a : AddLocalization s) (b : AddLocalization s) : a < b ↔ a ≤ b ∧ ¬b ≤ a

theorem AddLocalization.partialOrder.proof_4 {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} (a : AddLocalization s) (b : AddLocalization s) : a ≤ b → b ≤ a → a = b

instance Localization.partialOrder {α : Type u_1} [OrderedCancelCommMonoid α] {s : Submonoid α} : PartialOrder (Localization s)

Equations

• Localization.partialOrder = PartialOrder.mk (_ : ∀ (a b : Localization s), a ≤ b → b ≤ a → a = b)

theorem AddLocalization.orderedAddCancelCommMonoid.proof_4 {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} (a : AddLocalization s) (b : AddLocalization s) (c : AddLocalization s) : a + b ≤ a + c → b ≤ c

theorem AddLocalization.orderedAddCancelCommMonoid.proof_3 {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} (a : AddLocalization s) (b : AddLocalization s) : a ≤ b → ∀ (c : AddLocalization s), c + a ≤ c + b

instance AddLocalization.orderedAddCancelCommMonoid {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} : OrderedCancelAddCommMonoid (AddLocalization s)

Equations

• One or more equations did not get rendered due to their size.

theorem AddLocalization.orderedAddCancelCommMonoid.proof_2 {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} (a : AddLocalization s) (b : AddLocalization s) : a ≤ b → b ≤ a → a = b

theorem AddLocalization.orderedAddCancelCommMonoid.proof_1 {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} (a : AddLocalization s) (b : AddLocalization s) : a + b = b + a

instance Localization.orderedCancelCommMonoid {α : Type u_1} [OrderedCancelCommMonoid α] {s : Submonoid α} : OrderedCancelCommMonoid (Localization s)

Equations

• One or more equations did not get rendered due to their size.

instance AddLocalization.decidableLE {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} [DecidableRel fun x x_1 => x ≤ x_1] : DecidableRel fun x x_1 => x ≤ x_1

Equations

• One or more equations did not get rendered due to their size.

theorem AddLocalization.decidableLE.proof_1 {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} (a : α) (c : α) (b : { x // x ∈ s }) (d : { x // x ∈ s }) : Subsingleton (Decidable ((fun x x_1 => x ≤ x_1) (AddLocalization.mk a b) (AddLocalization.mk c d)))

instance Localization.decidableLE {α : Type u_1} [OrderedCancelCommMonoid α] {s : Submonoid α} [DecidableRel fun x x_1 => x ≤ x_1] : DecidableRel fun x x_1 => x ≤ x_1

Equations

• One or more equations did not get rendered due to their size.

theorem AddLocalization.decidableLT.proof_1 {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} (a : α) (c : α) (b : { x // x ∈ s }) (d : { x // x ∈ s }) : Subsingleton (Decidable ((fun x x_1 => x < x_1) (AddLocalization.mk a b) (AddLocalization.mk c d)))

instance AddLocalization.decidableLT {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} [DecidableRel fun x x_1 => x < x_1] : DecidableRel fun x x_1 => x < x_1

Equations

• One or more equations did not get rendered due to their size.

instance Localization.decidableLT {α : Type u_1} [OrderedCancelCommMonoid α] {s : Submonoid α} [DecidableRel fun x x_1 => x < x_1] : DecidableRel fun x x_1 => x < x_1

Equations

• One or more equations did not get rendered due to their size.

def AddLocalization.mkOrderEmbedding {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} (b : { x // x ∈ s }) : α ↪o AddLocalization s

An ordered cancellative monoid injects into its localization by sending a to a - b.

Equations

• One or more equations did not get rendered due to their size.

theorem AddLocalization.mkOrderEmbedding.proof_2 {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} (b : { x // x ∈ s }) {a : α} {b : α} : AddLocalization.mk a b ≤ AddLocalization.mk b b ↔ a ≤ b

theorem AddLocalization.mkOrderEmbedding.proof_1 {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} (b : { x // x ∈ s }) : Function.Injective fun a => AddLocalization.mk a b

@[simp]

theorem AddLocalization.mkOrderEmbedding_apply {α : Type u_1} [OrderedCancelAddCommMonoid α] {s : AddSubmonoid α} (b : { x // x ∈ s }) (a : α) : ↑(AddLocalization.mkOrderEmbedding b) a = AddSubmonoid.LocalizationMap.mk' (AddLocalization.addMonoidOf s) a b

@[simp]

theorem Localization.mkOrderEmbedding_apply {α : Type u_1} [OrderedCancelCommMonoid α] {s : Submonoid α} (b : { x // x ∈ s }) (a : α) : ↑(Localization.mkOrderEmbedding b) a = Submonoid.LocalizationMap.mk' (Localization.monoidOf s) a b

def Localization.mkOrderEmbedding {α : Type u_1} [OrderedCancelCommMonoid α] {s : Submonoid α} (b : { x // x ∈ s }) : α ↪o Localization s

An ordered cancellative monoid injects into its localization by sending a to a / b.

Equations

• One or more equations did not get rendered due to their size.

instance AddLocalization.instLinearOrderedAddCancelCommMonoidLocalizationToAddCommMonoidToOrderedAddCancelCommMonoid {α : Type u_1} [LinearOrderedCancelAddCommMonoid α] {s : AddSubmonoid α} : LinearOrderedCancelAddCommMonoid (AddLocalization s)

Equations

• One or more equations did not get rendered due to their size.

theorem AddLocalization.instLinearOrderedAddCancelCommMonoidLocalizationToAddCommMonoidToOrderedAddCancelCommMonoid.proof_1 {α : Type u_1} [LinearOrderedCancelAddCommMonoid α] {s : AddSubmonoid α} (a : AddLocalization s) (b : AddLocalization s) : a ≤ b → ∀ (c : AddLocalization s), c + a ≤ c + b

theorem AddLocalization.instLinearOrderedAddCancelCommMonoidLocalizationToAddCommMonoidToOrderedAddCancelCommMonoid.proof_4 {α : Type u_1} [LinearOrderedCancelAddCommMonoid α] {s : AddSubmonoid α} (a : AddLocalization s) (b : AddLocalization s) : a ≤ b ∨ b ≤ a

theorem AddLocalization.instLinearOrderedAddCancelCommMonoidLocalizationToAddCommMonoidToOrderedAddCancelCommMonoid.proof_2 {α : Type u_1} [LinearOrderedCancelAddCommMonoid α] {s : AddSubmonoid α} (a : AddLocalization s) (b : AddLocalization s) (c : AddLocalization s) : a + b ≤ a + c → b ≤ c

theorem AddLocalization.instLinearOrderedAddCancelCommMonoidLocalizationToAddCommMonoidToOrderedAddCancelCommMonoid.proof_3 {α : Type u_1} [LinearOrderedCancelAddCommMonoid α] {s : AddSubmonoid α} (a : AddLocalization s) (b : AddLocalization s) : a ≤ b → b ≤ a → a = b

theorem AddLocalization.instLinearOrderedAddCancelCommMonoidLocalizationToAddCommMonoidToOrderedAddCancelCommMonoid.proof_6 {α : Type u_1} [LinearOrderedCancelAddCommMonoid α] {s : AddSubmonoid α} : ∀ (a b : AddLocalization s), max a b = max a b

theorem AddLocalization.instLinearOrderedAddCancelCommMonoidLocalizationToAddCommMonoidToOrderedAddCancelCommMonoid.proof_7 {α : Type u_1} [LinearOrderedCancelAddCommMonoid α] {s : AddSubmonoid α} : ∀ (a b : AddLocalization s), compare a b = compare a b

theorem AddLocalization.instLinearOrderedAddCancelCommMonoidLocalizationToAddCommMonoidToOrderedAddCancelCommMonoid.proof_5 {α : Type u_1} [LinearOrderedCancelAddCommMonoid α] {s : AddSubmonoid α} : ∀ (a b : AddLocalization s), min a b = min a b

instance Localization.instLinearOrderedCancelCommMonoidLocalizationToCommMonoidToOrderedCancelCommMonoid {α : Type u_1} [LinearOrderedCancelCommMonoid α] {s : Submonoid α} : LinearOrderedCancelCommMonoid (Localization s)

Equations

• One or more equations did not get rendered due to their size.