ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Submonoid.LocalizationMap.ofMulEquivOfDom_id
@[to_additive (attr := simp) "A special case of `f ∘ id = f`, `f` a Localization map."]
theorem ofMulEquivOfDom_id :
    f.ofMulEquivOfDom
        (show S.map (MulEquiv.refl M).toMonoidHom = S from
          Submonoid.ext fun x ↦ ⟨fun ⟨_, hy, h⟩ ↦ h ▸ hy, fun h ↦ ⟨x, h, rfl⟩⟩) = f 
Arguments: {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] (f : S.LocalizationMap N)
Goal: f.ofMulEquivOfDom ⋯ = f
-- AddSubmonoid.LocalizationMap.addEquivOfAddEquiv_eq_map_apply
@[to_additive (attr := simp)]
theorem mulEquivOfMulEquiv_eq_map_apply {k : LocalizationMap T Q} {j : M ≃* P}
    (H : S.map j.toMonoidHom = T) (x) :
    f.mulEquivOfMulEquiv k H x =
      f.map (fun y : S ↦ show j.toMonoidHom y ∈ T from H ▸ Set.mem_image_of_mem j y.2) k x 
Arguments: {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {T : AddSubmonoid P} {Q : Type u_4} [AddCommMonoid Q] {k : T.LocalizationMap Q} {j : M ≃+ P} (H : AddSubmonoid.map j.toAddMonoidHom S = T) (x : N)
Goal: (f.addEquivOfAddEquiv k H) x = (f.map ⋯ k) x
-- Submonoid.LocalizationMap.mulEquivOfMulEquiv_eq_map_apply
@[to_additive (attr := simp)]
theorem mulEquivOfMulEquiv_eq_map_apply {k : LocalizationMap T Q} {j : M ≃* P}
    (H : S.map j.toMonoidHom = T) (x) :
    f.mulEquivOfMulEquiv k H x =
      f.map (fun y : S ↦ show j.toMonoidHom y ∈ T from H ▸ Set.mem_image_of_mem j y.2) k x 
Arguments: {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {T : Submonoid P} {Q : Type u_4} [CommMonoid Q] {k : T.LocalizationMap Q} {j : M ≃* P} (H : Submonoid.map j.toMonoidHom S = T) (x : N)
Goal: (f.mulEquivOfMulEquiv k H) x = (f.map ⋯ k) x
-- Submonoid.LocalizationMap.mulEquivOfMulEquiv_eq_map
@[to_additive]
theorem mulEquivOfMulEquiv_eq_map {k : LocalizationMap T Q} {j : M ≃* P}
    (H : S.map j.toMonoidHom = T) :
    (f.mulEquivOfMulEquiv k H).toMonoidHom =
      f.map (fun y : S ↦ show j.toMonoidHom y ∈ T from H ▸ Set.mem_image_of_mem j y.2) k 
Arguments: {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {T : Submonoid P} {Q : Type u_4} [CommMonoid Q] {k : T.LocalizationMap Q} {j : M ≃* P} (H : Submonoid.map j.toMonoidHom S = T)
Goal: (f.mulEquivOfMulEquiv k H).toMonoidHom = f.map ⋯ k
-- AddSubmonoid.LocalizationMap.addEquivOfAddEquiv_eq_map
@[to_additive]
theorem mulEquivOfMulEquiv_eq_map {k : LocalizationMap T Q} {j : M ≃* P}
    (H : S.map j.toMonoidHom = T) :
    (f.mulEquivOfMulEquiv k H).toMonoidHom =
      f.map (fun y : S ↦ show j.toMonoidHom y ∈ T from H ▸ Set.mem_image_of_mem j y.2) k 
Arguments: {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {T : AddSubmonoid P} {Q : Type u_4} [AddCommMonoid Q] {k : T.LocalizationMap Q} {j : M ≃+ P} (H : AddSubmonoid.map j.toAddMonoidHom S = T)
Goal: (f.addEquivOfAddEquiv k H).toAddMonoidHom = f.map ⋯ k
-- AddSubmonoid.LocalizationMap.addEquivOfAddEquiv_eq
@[to_additive (attr := simp, nolint simpNF)]
theorem mulEquivOfMulEquiv_eq {k : LocalizationMap T Q} {j : M ≃* P} (H : S.map j.toMonoidHom = T)
    (x) :
    f.mulEquivOfMulEquiv k H (f.toMap x) = k.toMap (j x) 
Arguments: {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {T : AddSubmonoid P} {Q : Type u_4} [AddCommMonoid Q] {k : T.LocalizationMap Q} {j : M ≃+ P} (H : AddSubmonoid.map j.toAddMonoidHom S = T) (x : M)
Goal: (f.addEquivOfAddEquiv k H) (f.toMap x) = k.toMap (j x)
-- Submonoid.LocalizationMap.mulEquivOfMulEquiv_eq
@[to_additive (attr := simp, nolint simpNF)]
theorem mulEquivOfMulEquiv_eq {k : LocalizationMap T Q} {j : M ≃* P} (H : S.map j.toMonoidHom = T)
    (x) :
    f.mulEquivOfMulEquiv k H (f.toMap x) = k.toMap (j x) 
Arguments: {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {T : Submonoid P} {Q : Type u_4} [CommMonoid Q] {k : T.LocalizationMap Q} {j : M ≃* P} (H : Submonoid.map j.toMonoidHom S = T) (x : M)
Goal: (f.mulEquivOfMulEquiv k H) (f.toMap x) = k.toMap (j x)
-- AddSubmonoid.LocalizationMap.addEquivOfAddEquiv_mk'
@[to_additive (attr := simp, nolint simpNF)]
theorem mulEquivOfMulEquiv_mk' {k : LocalizationMap T Q} {j : M ≃* P} (H : S.map j.toMonoidHom = T)
    (x y) :
    f.mulEquivOfMulEquiv k H (f.mk' x y) = k.mk' (j x) ⟨j y, H ▸ Set.mem_image_of_mem j y.2⟩ 
Arguments: {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {T : AddSubmonoid P} {Q : Type u_4} [AddCommMonoid Q] {k : T.LocalizationMap Q} {j : M ≃+ P} (H : AddSubmonoid.map j.toAddMonoidHom S = T) (x : M) (y : ↥S)
Goal: (f.addEquivOfAddEquiv k H) (f.mk' x y) = k.mk' (j x) ⟨j ↑y, ⋯⟩
-- Submonoid.LocalizationMap.mulEquivOfMulEquiv_mk'
@[to_additive (attr := simp, nolint simpNF)]
theorem mulEquivOfMulEquiv_mk' {k : LocalizationMap T Q} {j : M ≃* P} (H : S.map j.toMonoidHom = T)
    (x y) :
    f.mulEquivOfMulEquiv k H (f.mk' x y) = k.mk' (j x) ⟨j y, H ▸ Set.mem_image_of_mem j y.2⟩ 
Arguments: {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {T : Submonoid P} {Q : Type u_4} [CommMonoid Q] {k : T.LocalizationMap Q} {j : M ≃* P} (H : Submonoid.map j.toMonoidHom S = T) (x : M) (y : ↥S)
Goal: (f.mulEquivOfMulEquiv k H) (f.mk' x y) = k.mk' (j x) ⟨j ↑y, ⋯⟩
-- AddSubmonoid.LocalizationMap.of_addEquivOfAddEquiv_apply
@[to_additive (attr := simp, nolint simpNF)]
theorem of_mulEquivOfMulEquiv_apply {k : LocalizationMap T Q} {j : M ≃* P}
    (H : S.map j.toMonoidHom = T) (x) :
    (f.ofMulEquivOfLocalizations (f.mulEquivOfMulEquiv k H)).toMap x = k.toMap (j x) 
Arguments: {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {T : AddSubmonoid P} {Q : Type u_4} [AddCommMonoid Q] {k : T.LocalizationMap Q} {j : M ≃+ P} (H : AddSubmonoid.map j.toAddMonoidHom S = T) (x : M)
Goal: (f.ofAddEquivOfLocalizations (f.addEquivOfAddEquiv k H)).toMap x = k.toMap (j x)
-- Submonoid.LocalizationMap.of_mulEquivOfMulEquiv_apply
@[to_additive (attr := simp, nolint simpNF)]
theorem of_mulEquivOfMulEquiv_apply {k : LocalizationMap T Q} {j : M ≃* P}
    (H : S.map j.toMonoidHom = T) (x) :
    (f.ofMulEquivOfLocalizations (f.mulEquivOfMulEquiv k H)).toMap x = k.toMap (j x) 
Arguments: {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {T : Submonoid P} {Q : Type u_4} [CommMonoid Q] {k : T.LocalizationMap Q} {j : M ≃* P} (H : Submonoid.map j.toMonoidHom S = T) (x : M)
Goal: (f.ofMulEquivOfLocalizations (f.mulEquivOfMulEquiv k H)).toMap x = k.toMap (j x)
-- Submonoid.LocalizationMap.of_mulEquivOfMulEquiv
@[to_additive]
theorem of_mulEquivOfMulEquiv {k : LocalizationMap T Q} {j : M ≃* P} (H : S.map j.toMonoidHom = T) :
    (f.ofMulEquivOfLocalizations (f.mulEquivOfMulEquiv k H)).toMap = k.toMap.comp j.toMonoidHom 
Arguments: {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {P : Type u_3} [CommMonoid P] (f : S.LocalizationMap N) {T : Submonoid P} {Q : Type u_4} [CommMonoid Q] {k : T.LocalizationMap Q} {j : M ≃* P} (H : Submonoid.map j.toMonoidHom S = T)
Goal: (f.ofMulEquivOfLocalizations (f.mulEquivOfMulEquiv k H)).toMap = k.toMap.comp j.toMonoidHom
-- AddSubmonoid.LocalizationMap.of_addEquivOfAddEquiv
@[to_additive]
theorem of_mulEquivOfMulEquiv {k : LocalizationMap T Q} {j : M ≃* P} (H : S.map j.toMonoidHom = T) :
    (f.ofMulEquivOfLocalizations (f.mulEquivOfMulEquiv k H)).toMap = k.toMap.comp j.toMonoidHom 
Arguments: {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {P : Type u_3} [AddCommMonoid P] (f : S.LocalizationMap N) {T : AddSubmonoid P} {Q : Type u_4} [AddCommMonoid Q] {k : T.LocalizationMap Q} {j : M ≃+ P} (H : AddSubmonoid.map j.toAddMonoidHom S = T)
Goal: (f.ofAddEquivOfLocalizations (f.addEquivOfAddEquiv k H)).toMap = k.toMap.comp j.toAddMonoidHom
-- Localization.mk_one_eq_monoidOf_mk
@[to_additive]
theorem mk_one_eq_monoidOf_mk (x) : mk x 1 = (monoidOf S).toMap x 
Arguments: {M : Type u_1} [CommMonoid M] {S : Submonoid M} (x : M)
Goal: Localization.mk x 1 = (Localization.monoidOf S).toMap x
-- AddLocalization.mk_zero_eq_addMonoidOf_mk
@[to_additive]
theorem mk_one_eq_monoidOf_mk (x) : mk x 1 = (monoidOf S).toMap x 
Arguments: {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} (x : M)
Goal: AddLocalization.mk x 0 = (AddLocalization.addMonoidOf S).toMap x
-- AddLocalization.mk_eq_addMonoidOf_mk'_apply
@[to_additive]
theorem mk_eq_monoidOf_mk'_apply (x y) : mk x y = (monoidOf S).mk' x y 
Arguments: {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} (x : M) (y : ↥S)
Goal: AddLocalization.mk x y = (AddLocalization.addMonoidOf S).mk' x y
-- Localization.mk_eq_monoidOf_mk'_apply
@[to_additive]
theorem mk_eq_monoidOf_mk'_apply (x y) : mk x y = (monoidOf S).mk' x y 
Arguments: {M : Type u_1} [CommMonoid M] {S : Submonoid M} (x : M) (y : ↥S)
Goal: Localization.mk x y = (Localization.monoidOf S).mk' x y
-- Localization.mk_eq_monoidOf_mk'
@[to_additive (attr := simp)]
theorem mk_eq_monoidOf_mk' : mk = (monoidOf S).mk' 
Arguments: {M : Type u_1} [CommMonoid M] {S : Submonoid M}
Goal: Localization.mk = (Localization.monoidOf S).mk'
-- AddLocalization.mk_eq_addMonoidOf_mk'
@[to_additive (attr := simp)]
theorem mk_eq_monoidOf_mk' : mk = (monoidOf S).mk' 
Arguments: {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M}
Goal: AddLocalization.mk = (AddLocalization.addMonoidOf S).mk'
-- AddLocalization.liftOn_mk'
@[to_additive (attr := simp)]
theorem liftOn_mk' {p : Sort u} (f : M → S → p) (H) (a : M) (b : S) :
    liftOn ((monoidOf S).mk' a b) f H = f a b 
Arguments: {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u} (f : M → ↥S → p) (H : ∀ {a c : M} {b d : ↥S}, (AddLocalization.r S) (a, b) (c, d) → f a b = f c d) (a : M) (b : ↥S)
Goal: ((AddLocalization.addMonoidOf S).mk' a b).liftOn f H = f a b
-- Localization.liftOn_mk'
@[to_additive (attr := simp)]
theorem liftOn_mk' {p : Sort u} (f : M → S → p) (H) (a : M) (b : S) :
    liftOn ((monoidOf S).mk' a b) f H = f a b 
Arguments: {M : Type u_1} [CommMonoid M] {S : Submonoid M} {p : Sort u} (f : M → ↥S → p) (H : ∀ {a c : M} {b d : ↥S}, (Localization.r S) (a, b) (c, d) → f a b = f c d) (a : M) (b : ↥S)
Goal: ((Localization.monoidOf S).mk' a b).liftOn f H = f a b
-- AddLocalization.liftOn₂_mk'
@[to_additive (attr := simp)]
theorem liftOn₂_mk' {p : Sort*} (f : M → S → M → S → p) (H) (a c : M) (b d : S) :
    liftOn₂ ((monoidOf S).mk' a b) ((monoidOf S).mk' c d) f H = f a b c d 
Arguments: {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u_4} (f : M → ↥S → M → ↥S → p) (H :
  ∀ {a a' : M} {b b' : ↥S} {c c' : M} {d d' : ↥S},
    (AddLocalization.r S) (a, b) (a', b') → (AddLocalization.r S) (c, d) (c', d') → f a b c d = f a' b' c' d') (a c : M) (b d : ↥S)
Goal: ((AddLocalization.addMonoidOf S).mk' a b).liftOn₂ ((AddLocalization.addMonoidOf S).mk' c d) f H = f a b c d
-- Localization.liftOn₂_mk'
@[to_additive (attr := simp)]
theorem liftOn₂_mk' {p : Sort*} (f : M → S → M → S → p) (H) (a c : M) (b d : S) :
    liftOn₂ ((monoidOf S).mk' a b) ((monoidOf S).mk' c d) f H = f a b c d 
Arguments: {M : Type u_1} [CommMonoid M] {S : Submonoid M} {p : Sort u_4} (f : M → ↥S → M → ↥S → p) (H :
  ∀ {a a' : M} {b b' : ↥S} {c c' : M} {d d' : ↥S},
    (Localization.r S) (a, b) (a', b') → (Localization.r S) (c, d) (c', d') → f a b c d = f a' b' c' d') (a c : M) (b d : ↥S)
Goal: ((Localization.monoidOf S).mk' a b).liftOn₂ ((Localization.monoidOf S).mk' c d) f H = f a b c d
-- Localization.mulEquivOfQuotient_apply
@[to_additive (attr := simp)]
theorem mulEquivOfQuotient_apply (x) : mulEquivOfQuotient f x = (monoidOf S).lift f.map_units x 
Arguments: {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : S.LocalizationMap N} (x : Localization S)
Goal: (Localization.mulEquivOfQuotient f) x = ((Localization.monoidOf S).lift ⋯) x
-- AddLocalization.addEquivOfQuotient_apply
@[to_additive (attr := simp)]
theorem mulEquivOfQuotient_apply (x) : mulEquivOfQuotient f x = (monoidOf S).lift f.map_units x 
Arguments: {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : S.LocalizationMap N} (x : AddLocalization S)
Goal: (AddLocalization.addEquivOfQuotient f) x = ((AddLocalization.addMonoidOf S).lift ⋯) x
-- AddLocalization.addEquivOfQuotient_mk'
@[to_additive (attr := simp, nolint simpNF)]
theorem mulEquivOfQuotient_mk' (x y) : mulEquivOfQuotient f ((monoidOf S).mk' x y) = f.mk' x y 
Arguments: {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : S.LocalizationMap N} (x : M) (y : ↥S)
Goal: (AddLocalization.addEquivOfQuotient f) ((AddLocalization.addMonoidOf S).mk' x y) = f.mk' x y
-- Localization.mulEquivOfQuotient_mk'
@[to_additive (attr := simp, nolint simpNF)]
theorem mulEquivOfQuotient_mk' (x y) : mulEquivOfQuotient f ((monoidOf S).mk' x y) = f.mk' x y 
Arguments: {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : S.LocalizationMap N} (x : M) (y : ↥S)
Goal: (Localization.mulEquivOfQuotient f) ((Localization.monoidOf S).mk' x y) = f.mk' x y
-- Localization.mulEquivOfQuotient_mk
@[to_additive]
theorem mulEquivOfQuotient_mk (x y) : mulEquivOfQuotient f (mk x y) = f.mk' x y 
Arguments: {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : S.LocalizationMap N} (x : M) (y : ↥S)
Goal: (Localization.mulEquivOfQuotient f) (Localization.mk x y) = f.mk' x y
-- AddLocalization.addEquivOfQuotient_mk
@[to_additive]
theorem mulEquivOfQuotient_mk (x y) : mulEquivOfQuotient f (mk x y) = f.mk' x y 
Arguments: {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : S.LocalizationMap N} (x : M) (y : ↥S)
Goal: (AddLocalization.addEquivOfQuotient f) (AddLocalization.mk x y) = f.mk' x y
-- AddLocalization.addEquivOfQuotient_addMonoidOf
@[to_additive]
theorem mulEquivOfQuotient_monoidOf (x) :
    mulEquivOfQuotient f ((monoidOf S).toMap x) = f.toMap x 
Arguments: {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : S.LocalizationMap N} (x : M)
Goal: (AddLocalization.addEquivOfQuotient f) ((AddLocalization.addMonoidOf S).toMap x) = f.toMap x
-- Localization.mulEquivOfQuotient_monoidOf
@[to_additive]
theorem mulEquivOfQuotient_monoidOf (x) :
    mulEquivOfQuotient f ((monoidOf S).toMap x) = f.toMap x 
Arguments: {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : S.LocalizationMap N} (x : M)
Goal: (Localization.mulEquivOfQuotient f) ((Localization.monoidOf S).toMap x) = f.toMap x
-- AddLocalization.addEquivOfQuotient_symm_mk'
@[to_additive (attr := simp)]
theorem mulEquivOfQuotient_symm_mk' (x y) :
    (mulEquivOfQuotient f).symm (f.mk' x y) = (monoidOf S).mk' x y 
Arguments: {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : S.LocalizationMap N} (x : M) (y : ↥S)
Goal: (AddLocalization.addEquivOfQuotient f).symm (f.mk' x y) = (AddLocalization.addMonoidOf S).mk' x y
-- Localization.mulEquivOfQuotient_symm_mk'
@[to_additive (attr := simp)]
theorem mulEquivOfQuotient_symm_mk' (x y) :
    (mulEquivOfQuotient f).symm (f.mk' x y) = (monoidOf S).mk' x y 
Arguments: {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : S.LocalizationMap N} (x : M) (y : ↥S)
Goal: (Localization.mulEquivOfQuotient f).symm (f.mk' x y) = (Localization.monoidOf S).mk' x y
-- AddLocalization.addEquivOfQuotient_symm_mk
@[to_additive]
theorem mulEquivOfQuotient_symm_mk (x y) : (mulEquivOfQuotient f).symm (f.mk' x y) = mk x y 
Arguments: {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : S.LocalizationMap N} (x : M) (y : ↥S)
Goal: (AddLocalization.addEquivOfQuotient f).symm (f.mk' x y) = AddLocalization.mk x y
-- Localization.mulEquivOfQuotient_symm_mk
@[to_additive]
theorem mulEquivOfQuotient_symm_mk (x y) : (mulEquivOfQuotient f).symm (f.mk' x y) = mk x y 
Arguments: {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : S.LocalizationMap N} (x : M) (y : ↥S)
Goal: (Localization.mulEquivOfQuotient f).symm (f.mk' x y) = Localization.mk x y
-- Localization.mulEquivOfQuotient_symm_monoidOf
@[to_additive (attr := simp)]
theorem mulEquivOfQuotient_symm_monoidOf (x) :
    (mulEquivOfQuotient f).symm (f.toMap x) = (monoidOf S).toMap x 
Arguments: {M : Type u_1} [CommMonoid M] {S : Submonoid M} {N : Type u_2} [CommMonoid N] {f : S.LocalizationMap N} (x : M)
Goal: (Localization.mulEquivOfQuotient f).symm (f.toMap x) = (Localization.monoidOf S).toMap x
-- AddLocalization.addEquivOfQuotient_symm_addMonoidOf
@[to_additive (attr := simp)]
theorem mulEquivOfQuotient_symm_monoidOf (x) :
    (mulEquivOfQuotient f).symm (f.toMap x) = (monoidOf S).toMap x 
Arguments: {M : Type u_1} [AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [AddCommMonoid N] {f : S.LocalizationMap N} (x : M)
Goal: (AddLocalization.addEquivOfQuotient f).symm (f.toMap x) = (AddLocalization.addMonoidOf S).toMap x
-- Localization.Away.mk_eq_monoidOf_mk'
@[to_additive]
theorem Away.mk_eq_monoidOf_mk' : mk = (Away.monoidOf x).mk' 
Arguments: {M : Type u_1} [CommMonoid M] (x : M)
Goal: Localization.mk = Submonoid.LocalizationMap.mk' (Localization.Away.monoidOf x)
-- AddLocalization.Away.mk_eq_addMonoidOf_mk'
@[to_additive]
theorem Away.mk_eq_monoidOf_mk' : mk = (Away.monoidOf x).mk' 
Arguments: {M : Type u_1} [AddCommMonoid M] (x : M)
Goal: AddLocalization.mk = AddSubmonoid.LocalizationMap.mk' (AddLocalization.Away.addMonoidOf x)
-- Localization.mk_left_injective
@[to_additive]
theorem mk_left_injective (b : s) : Injective fun a => mk a b 
Arguments: {α : Type u_1} [CancelCommMonoid α] {s : Submonoid α} (b : ↥s)
Goal: Function.Injective fun a => Localization.mk a b
-- AddLocalization.mk_left_injective
@[to_additive]
theorem mk_left_injective (b : s) : Injective fun a => mk a b 
Arguments: {α : Type u_1} [AddCancelCommMonoid α] {s : AddSubmonoid α} (b : ↥s)
Goal: Function.Injective fun a => AddLocalization.mk a b
-- Localization.mk_eq_mk_iff'
@[to_additive]
theorem mk_eq_mk_iff' : mk a₁ a₂ = mk b₁ b₂ ↔ ↑b₂ * a₁ = a₂ * b₁ 
Arguments: {α : Type u_1} [CancelCommMonoid α] {s : Submonoid α} {a₁ b₁ : α} {a₂ b₂ : ↥s}
Goal: Localization.mk a₁ a₂ = Localization.mk b₁ b₂ ↔ ↑b₂ * a₁ = ↑a₂ * b₁
-- AddLocalization.mk_eq_mk_iff'
@[to_additive]
theorem mk_eq_mk_iff' : mk a₁ a₂ = mk b₁ b₂ ↔ ↑b₂ * a₁ = a₂ * b₁ 
Arguments: {α : Type u_1} [AddCancelCommMonoid α] {s : AddSubmonoid α} {a₁ b₁ : α} {a₂ b₂ : ↥s}
Goal: AddLocalization.mk a₁ a₂ = AddLocalization.mk b₁ b₂ ↔ ↑b₂ + a₁ = ↑a₂ + b₁
-- EquivFunctor.map_refl'
class EquivFunctor (f : Type u₀ → Type u₁) where
    map : ∀ {α β}, α ≃ β → f α → f β
    map_refl' : ∀ α, map (Equiv.refl α) = @id (f α) := by rfl
    map_trans' : ∀ {α β γ} (k : α ≃ β) (h : β ≃ γ), map (k.trans h) = map h ∘ map k := by rfl
Arguments: {f : Type u₀ → Type u₁} [self : EquivFunctor f] (α : Type u₀)
Goal: EquivFunctor.map (Equiv.refl α) = id
-- EquivFunctor.map_trans'
class EquivFunctor (f : Type u₀ → Type u₁) where
    map : ∀ {α β}, α ≃ β → f α → f β
    map_refl' : ∀ α, map (Equiv.refl α) = @id (f α) := by rfl
    map_trans' : ∀ {α β γ} (k : α ≃ β) (h : β ≃ γ), map (k.trans h) = map h ∘ map k := by rfl
Arguments: {f : Type u₀ → Type u₁} [self : EquivFunctor f] {α β γ : Type u₀} (k : α ≃ β) (h : β ≃ γ)
Goal: EquivFunctor.map (k.trans h) = EquivFunctor.map h ∘ EquivFunctor.map k
-- EquivFunctor.mapEquiv_apply
@[simp]
theorem mapEquiv_apply (x : f α) : mapEquiv f e x = EquivFunctor.map e x 
Arguments: (f : Type u₀ → Type u₁) [EquivFunctor f] {α β : Type u₀} (e : α ≃ β) (x : f α)
Goal: (EquivFunctor.mapEquiv f e) x = EquivFunctor.map e x
-- EquivFunctor.mapEquiv_symm_apply
theorem mapEquiv_symm_apply (y : f β) : (mapEquiv f e).symm y = EquivFunctor.map e.symm y 
Arguments: (f : Type u₀ → Type u₁) [EquivFunctor f] {α β : Type u₀} (e : α ≃ β) (y : f β)
Goal: (EquivFunctor.mapEquiv f e).symm y = EquivFunctor.map e.symm y
-- EquivFunctor.mapEquiv_refl
@[simp]
theorem mapEquiv_refl (α) : mapEquiv f (Equiv.refl α) = Equiv.refl (f α) 
Arguments: (f : Type u₀ → Type u₁) [EquivFunctor f] (α : Type u₀)
Goal: EquivFunctor.mapEquiv f (Equiv.refl α) = Equiv.refl (f α)
-- EquivFunctor.mapEquiv_symm
@[simp]
theorem mapEquiv_symm : (mapEquiv f e).symm = mapEquiv f e.symm 
Arguments: (f : Type u₀ → Type u₁) [EquivFunctor f] {α β : Type u₀} (e : α ≃ β)
Goal: (EquivFunctor.mapEquiv f e).symm = EquivFunctor.mapEquiv f e.symm
-- EquivFunctor.mapEquiv_trans
@[simp]
theorem mapEquiv_trans {γ : Type u₀} (ab : α ≃ β) (bc : β ≃ γ) :
    (mapEquiv f ab).trans (mapEquiv f bc) = mapEquiv f (ab.trans bc) 
Arguments: (f : Type u₀ → Type u₁) [EquivFunctor f] {α β γ : Type u₀} (ab : α ≃ β) (bc : β ≃ γ)
Goal: (EquivFunctor.mapEquiv f ab).trans (EquivFunctor.mapEquiv f bc) = EquivFunctor.mapEquiv f (ab.trans bc)
-- EquivFunctor.mapEquiv.injective
theorem mapEquiv.injective (f : Type u₀ → Type u₁)
    [Applicative f] [LawfulApplicative f] {α β : Type u₀}
    (h : ∀ γ, Function.Injective (pure : γ → f γ)) :
      Function.Injective (@EquivFunctor.mapEquiv f _ α β) 
Arguments: (f : Type u₀ → Type u₁) [Applicative f] [LawfulApplicative f] {α β : Type u₀} (h : ∀ (γ : Type u₀), Function.Injective pure)
Goal: Function.Injective (EquivFunctor.mapEquiv f)
-- LawfulBitraversable.comp_bitraverse
class LawfulBitraversable (t : Type u → Type u → Type u) [Bitraversable t] extends
  LawfulBifunctor t : Prop where
  -- Porting note: need to specify `m := Id` because `id` no longer has a `Monad` instance
  id_bitraverse : ∀ {α β} (x : t α β), bitraverse (m := Id) pure pure x = pure x
  comp_bitraverse :
    ∀ {F G} [Applicative F] [Applicative G] [LawfulApplicative F] [LawfulApplicative G]
      {α α' β β' γ γ'} (f : β → F γ) (f' : β' → F γ') (g : α → G β) (g' : α' → G β') (x : t α α'),
      bitraverse (Comp.mk ∘ map f ∘ g) (Comp.mk ∘ map f' ∘ g') x =
        Comp.mk (bitraverse f f' <$> bitraverse g g' x)
  bitraverse_eq_bimap_id :
    ∀ {α α' β β'} (f : α → β) (f' : α' → β') (x : t α α'),
      bitraverse (m := Id) (pure ∘ f) (pure ∘ f') x = pure (bimap f f' x)
  binaturality :
    ∀ {F G} [Applicative F] [Applicative G] [LawfulApplicative F] [LawfulApplicative G]
      (η : ApplicativeTransformation F G) {α α' β β'} (f : α → F β) (f' : α' → F β') (x : t α α'),
      η (bitraverse f f' x) = bitraverse (@η _ ∘ f) (@η _ ∘ f') x
Arguments: {t : Type u → Type u → Type u} [Bitraversable t] [self : LawfulBitraversable t] {F G : Type u → Type u} [Applicative F] [Applicative G] [LawfulApplicative F] [LawfulApplicative G] {α α' β β' γ γ' : Type u} (f : β → F γ) (f' : β' → F γ') (g : α → G β) (g' : α' → G β') (x : t α α')
Goal: bitraverse (Functor.Comp.mk ∘ Functor.map f ∘ g) (Functor.Comp.mk ∘ Functor.map f' ∘ g') x =
  Functor.Comp.mk (bitraverse f f' <$> bitraverse g g' x)