Theorem: AddCommGroupCat.injective_of_injective_as_module
File: Mathlib/Algebra/Category/GroupCat/Injective.lean

tactic: let G : (⟨X⟩ : ModuleCat ℤ) ⟶ ⟨A⟩ :=
  { g with
    map_smul' := by
      intros
      dsimp
      rw [map_zsmul] }
state_before: A : Type u
inst✝¹ : AddCommGroup A
inst✝ : Injective (ModuleCat.mk A)
X Y : Bundled AddCommGroup
g : X ⟶ Bundled.mk A
f : X ⟶ Y
m : Mono f
⊢ ∃ h, f ≫ h = g

tactic: let F : (⟨X⟩ : ModuleCat ℤ) ⟶ ⟨Y⟩ :=
  { f with
    map_smul' := by
      intros
      dsimp
      rw [map_zsmul] }
state_before: A : Type u
inst✝¹ : AddCommGroup A
inst✝ : Injective (ModuleCat.mk A)
X Y : Bundled AddCommGroup
g : X ⟶ Bundled.mk A
f : X ⟶ Y
m : Mono f
G : ModuleCat.mk ↑X ⟶ ModuleCat.mk A :=
  {
    toAddHom :=
      { toFun := g.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := g.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := g.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
                x) }
⊢ ∃ h, f ≫ h = g

tactic: have : Mono F := by
  refine' ⟨fun {Z} α β eq1 => _⟩
  let α' : AddCommGroupCat.of Z ⟶ X := @LinearMap.toAddMonoidHom _ _ _ _ _ _ _ _ (_) _ _ α
  let β' : AddCommGroupCat.of Z ⟶ X := @LinearMap.toAddMonoidHom _ _ _ _ _ _ _ _ (_) _ _ β
  have eq2 : α' ≫ f = β' ≫ f := by
    ext x
    simp only [CategoryTheory.comp_apply, LinearMap.toAddMonoidHom_coe]
    simpa only [ModuleCat.coe_comp, LinearMap.coe_mk, Function.comp_apply] using
      FunLike.congr_fun eq1 x
  rw [cancel_mono] at eq2
  have : ⇑α' = ⇑β' := congrArg _ eq2
  ext x
  apply congrFun this _
state_before: A : Type u
inst✝¹ : AddCommGroup A
inst✝ : Injective (ModuleCat.mk A)
X Y : Bundled AddCommGroup
g : X ⟶ Bundled.mk A
f : X ⟶ Y
m : Mono f
G : ModuleCat.mk ↑X ⟶ ModuleCat.mk A :=
  {
    toAddHom :=
      { toFun := g.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := g.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := g.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
                x) }
F : ModuleCat.mk ↑X ⟶ ModuleCat.mk ↑Y :=
  {
    toAddHom :=
      { toFun := f.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := f.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := f.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
                x) }
⊢ ∃ h, f ≫ h = g

tactic: refine' ⟨(Injective.factorThru G F).toAddMonoidHom, _⟩
state_before: A : Type u
inst✝¹ : AddCommGroup A
inst✝ : Injective (ModuleCat.mk A)
X Y : Bundled AddCommGroup
g : X ⟶ Bundled.mk A
f : X ⟶ Y
m : Mono f
G : ModuleCat.mk ↑X ⟶ ModuleCat.mk A :=
  {
    toAddHom :=
      { toFun := g.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := g.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := g.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
                x) }
F : ModuleCat.mk ↑X ⟶ ModuleCat.mk ↑Y :=
  {
    toAddHom :=
      { toFun := f.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := f.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := f.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
                x) }
this : Mono F
⊢ ∃ h, f ≫ h = g

tactic: ext x
state_before: A : Type u
inst✝¹ : AddCommGroup A
inst✝ : Injective (ModuleCat.mk A)
X Y : Bundled AddCommGroup
g : X ⟶ Bundled.mk A
f : X ⟶ Y
m : Mono f
G : ModuleCat.mk ↑X ⟶ ModuleCat.mk A :=
  {
    toAddHom :=
      { toFun := g.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := g.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := g.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
                x) }
F : ModuleCat.mk ↑X ⟶ ModuleCat.mk ↑Y :=
  {
    toAddHom :=
      { toFun := f.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := f.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := f.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
                x) }
this : Mono F
⊢ f ≫ LinearMap.toAddMonoidHom (Injective.factorThru G F) = g

tactic: convert FunLike.congr_fun (Injective.comp_factorThru G F) x
state_before: case w
A : Type u
inst✝¹ : AddCommGroup A
inst✝ : Injective (ModuleCat.mk A)
X Y : Bundled AddCommGroup
g : X ⟶ Bundled.mk A
f : X ⟶ Y
m : Mono f
G : ModuleCat.mk ↑X ⟶ ModuleCat.mk A :=
  {
    toAddHom :=
      { toFun := g.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := g.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := g.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
                x) }
F : ModuleCat.mk ↑X ⟶ ModuleCat.mk ↑Y :=
  {
    toAddHom :=
      { toFun := f.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := f.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := f.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
                x) }
this : Mono F
x : (forget (Bundled AddCommGroup)).obj X
⊢ (forget (Bundled AddCommGroup)).map (f ≫ LinearMap.toAddMonoidHom (Injective.factorThru G F)) x =
    (forget (Bundled AddCommGroup)).map g x

tactic: intros
state_before: A : Type u
inst✝¹ : AddCommGroup A
inst✝ : Injective (ModuleCat.mk A)
X Y : Bundled AddCommGroup
g : X ⟶ Bundled.mk A
f : X ⟶ Y
m : Mono f
⊢ ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
    AddHom.toFun
        { toFun := g.toFun,
          map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
        (r • x) =
      ↑(RingHom.id ℤ) r •
        AddHom.toFun
          { toFun := g.toFun,
            map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
          x

tactic: dsimp
state_before: A : Type u
inst✝¹ : AddCommGroup A
inst✝ : Injective (ModuleCat.mk A)
X Y : Bundled AddCommGroup
g : X ⟶ Bundled.mk A
f : X ⟶ Y
m : Mono f
r✝ : ℤ
x✝ : ↑(ModuleCat.mk ↑X)
⊢ AddHom.toFun
      { toFun := g.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
      (r✝ • x✝) =
    ↑(RingHom.id ℤ) r✝ •
      AddHom.toFun
        { toFun := g.toFun,
          map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
        x✝

tactic: rw [map_zsmul]
state_before: A : Type u
inst✝¹ : AddCommGroup A
inst✝ : Injective (ModuleCat.mk A)
X Y : Bundled AddCommGroup
g : X ⟶ Bundled.mk A
f : X ⟶ Y
m : Mono f
r✝ : ℤ
x✝ : ↑(ModuleCat.mk ↑X)
⊢ ↑g (r✝ • x✝) = r✝ • ↑g x✝

tactic: intros
state_before: A : Type u
inst✝¹ : AddCommGroup A
inst✝ : Injective (ModuleCat.mk A)
X Y : Bundled AddCommGroup
g : X ⟶ Bundled.mk A
f : X ⟶ Y
m : Mono f
G : ModuleCat.mk ↑X ⟶ ModuleCat.mk A :=
  {
    toAddHom :=
      { toFun := g.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := g.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := g.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
                x) }
⊢ ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
    AddHom.toFun
        { toFun := f.toFun,
          map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
        (r • x) =
      ↑(RingHom.id ℤ) r •
        AddHom.toFun
          { toFun := f.toFun,
            map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
          x

tactic: dsimp
state_before: A : Type u
inst✝¹ : AddCommGroup A
inst✝ : Injective (ModuleCat.mk A)
X Y : Bundled AddCommGroup
g : X ⟶ Bundled.mk A
f : X ⟶ Y
m : Mono f
G : ModuleCat.mk ↑X ⟶ ModuleCat.mk A :=
  {
    toAddHom :=
      { toFun := g.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := g.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := g.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
                x) }
r✝ : ℤ
x✝ : ↑(ModuleCat.mk ↑X)
⊢ AddHom.toFun
      { toFun := f.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
      (r✝ • x✝) =
    ↑(RingHom.id ℤ) r✝ •
      AddHom.toFun
        { toFun := f.toFun,
          map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
        x✝

tactic: rw [map_zsmul]
state_before: A : Type u
inst✝¹ : AddCommGroup A
inst✝ : Injective (ModuleCat.mk A)
X Y : Bundled AddCommGroup
g : X ⟶ Bundled.mk A
f : X ⟶ Y
m : Mono f
G : ModuleCat.mk ↑X ⟶ ModuleCat.mk A :=
  {
    toAddHom :=
      { toFun := g.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := g.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := g.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
                x) }
r✝ : ℤ
x✝ : ↑(ModuleCat.mk ↑X)
⊢ ↑f (r✝ • x✝) = r✝ • ↑f x✝

tactic: refine' ⟨fun {Z} α β eq1 => _⟩
state_before: A : Type u
inst✝¹ : AddCommGroup A
inst✝ : Injective (ModuleCat.mk A)
X Y : Bundled AddCommGroup
g : X ⟶ Bundled.mk A
f : X ⟶ Y
m : Mono f
G : ModuleCat.mk ↑X ⟶ ModuleCat.mk A :=
  {
    toAddHom :=
      { toFun := g.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := g.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := g.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
                x) }
F : ModuleCat.mk ↑X ⟶ ModuleCat.mk ↑Y :=
  {
    toAddHom :=
      { toFun := f.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := f.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := f.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
                x) }
⊢ Mono F

tactic: let α' : AddCommGroupCat.of Z ⟶ X := @LinearMap.toAddMonoidHom _ _ _ _ _ _ _ _ (_) _ _ α
state_before: A : Type u
inst✝¹ : AddCommGroup A
inst✝ : Injective (ModuleCat.mk A)
X Y : Bundled AddCommGroup
g : X ⟶ Bundled.mk A
f : X ⟶ Y
m : Mono f
G : ModuleCat.mk ↑X ⟶ ModuleCat.mk A :=
  {
    toAddHom :=
      { toFun := g.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := g.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := g.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
                x) }
F : ModuleCat.mk ↑X ⟶ ModuleCat.mk ↑Y :=
  {
    toAddHom :=
      { toFun := f.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := f.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := f.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
                x) }
Z : ModuleCat ℤ
α β : Z ⟶ ModuleCat.mk ↑X
eq1 : α ≫ F = β ≫ F
⊢ α = β

tactic: let β' : AddCommGroupCat.of Z ⟶ X := @LinearMap.toAddMonoidHom _ _ _ _ _ _ _ _ (_) _ _ β
state_before: A : Type u
inst✝¹ : AddCommGroup A
inst✝ : Injective (ModuleCat.mk A)
X Y : Bundled AddCommGroup
g : X ⟶ Bundled.mk A
f : X ⟶ Y
m : Mono f
G : ModuleCat.mk ↑X ⟶ ModuleCat.mk A :=
  {
    toAddHom :=
      { toFun := g.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := g.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := g.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
                x) }
F : ModuleCat.mk ↑X ⟶ ModuleCat.mk ↑Y :=
  {
    toAddHom :=
      { toFun := f.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := f.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := f.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
                x) }
Z : ModuleCat ℤ
α β : Z ⟶ ModuleCat.mk ↑X
eq1 : α ≫ F = β ≫ F
α' : of ↑Z ⟶ X := LinearMap.toAddMonoidHom α
⊢ α = β

tactic: have eq2 : α' ≫ f = β' ≫ f := by
  ext x
  simp only [CategoryTheory.comp_apply, LinearMap.toAddMonoidHom_coe]
  simpa only [ModuleCat.coe_comp, LinearMap.coe_mk, Function.comp_apply] using
    FunLike.congr_fun eq1 x
state_before: A : Type u
inst✝¹ : AddCommGroup A
inst✝ : Injective (ModuleCat.mk A)
X Y : Bundled AddCommGroup
g : X ⟶ Bundled.mk A
f : X ⟶ Y
m : Mono f
G : ModuleCat.mk ↑X ⟶ ModuleCat.mk A :=
  {
    toAddHom :=
      { toFun := g.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := g.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := g.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
                x) }
F : ModuleCat.mk ↑X ⟶ ModuleCat.mk ↑Y :=
  {
    toAddHom :=
      { toFun := f.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := f.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := f.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
                x) }
Z : ModuleCat ℤ
α β : Z ⟶ ModuleCat.mk ↑X
eq1 : α ≫ F = β ≫ F
α' : of ↑Z ⟶ X := LinearMap.toAddMonoidHom α
β' : of ↑Z ⟶ X := LinearMap.toAddMonoidHom β
⊢ α = β

tactic: rw [cancel_mono] at eq2
state_before: A : Type u
inst✝¹ : AddCommGroup A
inst✝ : Injective (ModuleCat.mk A)
X Y : Bundled AddCommGroup
g : X ⟶ Bundled.mk A
f : X ⟶ Y
m : Mono f
G : ModuleCat.mk ↑X ⟶ ModuleCat.mk A :=
  {
    toAddHom :=
      { toFun := g.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := g.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := g.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
                x) }
F : ModuleCat.mk ↑X ⟶ ModuleCat.mk ↑Y :=
  {
    toAddHom :=
      { toFun := f.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := f.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := f.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
                x) }
Z : ModuleCat ℤ
α β : Z ⟶ ModuleCat.mk ↑X
eq1 : α ≫ F = β ≫ F
α' : of ↑Z ⟶ X := LinearMap.toAddMonoidHom α
β' : of ↑Z ⟶ X := LinearMap.toAddMonoidHom β
eq2 : α' ≫ f = β' ≫ f
⊢ α = β

tactic: have : ⇑α' = ⇑β' := congrArg _ eq2
state_before: A : Type u
inst✝¹ : AddCommGroup A
inst✝ : Injective (ModuleCat.mk A)
X Y : Bundled AddCommGroup
g : X ⟶ Bundled.mk A
f : X ⟶ Y
m : Mono f
G : ModuleCat.mk ↑X ⟶ ModuleCat.mk A :=
  {
    toAddHom :=
      { toFun := g.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := g.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := g.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
                x) }
F : ModuleCat.mk ↑X ⟶ ModuleCat.mk ↑Y :=
  {
    toAddHom :=
      { toFun := f.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := f.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := f.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
                x) }
Z : ModuleCat ℤ
α β : Z ⟶ ModuleCat.mk ↑X
eq1 : α ≫ F = β ≫ F
α' : of ↑Z ⟶ X := LinearMap.toAddMonoidHom α
β' : of ↑Z ⟶ X := LinearMap.toAddMonoidHom β
eq2 : α' = β'
⊢ α = β

tactic: ext x
state_before: A : Type u
inst✝¹ : AddCommGroup A
inst✝ : Injective (ModuleCat.mk A)
X Y : Bundled AddCommGroup
g : X ⟶ Bundled.mk A
f : X ⟶ Y
m : Mono f
G : ModuleCat.mk ↑X ⟶ ModuleCat.mk A :=
  {
    toAddHom :=
      { toFun := g.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := g.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := g.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
                x) }
F : ModuleCat.mk ↑X ⟶ ModuleCat.mk ↑Y :=
  {
    toAddHom :=
      { toFun := f.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := f.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := f.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
                x) }
Z : ModuleCat ℤ
α β : Z ⟶ ModuleCat.mk ↑X
eq1 : α ≫ F = β ≫ F
α' : of ↑Z ⟶ X := LinearMap.toAddMonoidHom α
β' : of ↑Z ⟶ X := LinearMap.toAddMonoidHom β
eq2 : α' = β'
this : ↑α' = ↑β'
⊢ α = β

tactic: apply congrFun this _
state_before: case h
A : Type u
inst✝¹ : AddCommGroup A
inst✝ : Injective (ModuleCat.mk A)
X Y : Bundled AddCommGroup
g : X ⟶ Bundled.mk A
f : X ⟶ Y
m : Mono f
G : ModuleCat.mk ↑X ⟶ ModuleCat.mk A :=
  {
    toAddHom :=
      { toFun := g.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := g.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := g.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
                x) }
F : ModuleCat.mk ↑X ⟶ ModuleCat.mk ↑Y :=
  {
    toAddHom :=
      { toFun := f.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := f.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := f.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
                x) }
Z : ModuleCat ℤ
α β : Z ⟶ ModuleCat.mk ↑X
eq1 : α ≫ F = β ≫ F
α' : of ↑Z ⟶ X := LinearMap.toAddMonoidHom α
β' : of ↑Z ⟶ X := LinearMap.toAddMonoidHom β
eq2 : α' = β'
this : ↑α' = ↑β'
x : ↑Z
⊢ ↑α x = ↑β x

tactic: ext x
state_before: A : Type u
inst✝¹ : AddCommGroup A
inst✝ : Injective (ModuleCat.mk A)
X Y : Bundled AddCommGroup
g : X ⟶ Bundled.mk A
f : X ⟶ Y
m : Mono f
G : ModuleCat.mk ↑X ⟶ ModuleCat.mk A :=
  {
    toAddHom :=
      { toFun := g.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := g.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := g.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
                x) }
F : ModuleCat.mk ↑X ⟶ ModuleCat.mk ↑Y :=
  {
    toAddHom :=
      { toFun := f.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := f.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := f.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
                x) }
Z : ModuleCat ℤ
α β : Z ⟶ ModuleCat.mk ↑X
eq1 : α ≫ F = β ≫ F
α' : of ↑Z ⟶ X := LinearMap.toAddMonoidHom α
β' : of ↑Z ⟶ X := LinearMap.toAddMonoidHom β
⊢ α' ≫ f = β' ≫ f

tactic: simp only [CategoryTheory.comp_apply, LinearMap.toAddMonoidHom_coe]
state_before: case w
A : Type u
inst✝¹ : AddCommGroup A
inst✝ : Injective (ModuleCat.mk A)
X Y : Bundled AddCommGroup
g : X ⟶ Bundled.mk A
f : X ⟶ Y
m : Mono f
G : ModuleCat.mk ↑X ⟶ ModuleCat.mk A :=
  {
    toAddHom :=
      { toFun := g.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := g.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := g.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
                x) }
F : ModuleCat.mk ↑X ⟶ ModuleCat.mk ↑Y :=
  {
    toAddHom :=
      { toFun := f.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := f.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := f.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
                x) }
Z : ModuleCat ℤ
α β : Z ⟶ ModuleCat.mk ↑X
eq1 : α ≫ F = β ≫ F
α' : of ↑Z ⟶ X := LinearMap.toAddMonoidHom α
β' : of ↑Z ⟶ X := LinearMap.toAddMonoidHom β
x : ↑(of ↑Z)
⊢ ↑(α' ≫ f) x = ↑(β' ≫ f) x

tactic: simpa only [ModuleCat.coe_comp, LinearMap.coe_mk, Function.comp_apply] using
  FunLike.congr_fun eq1 x
state_before: case w
A : Type u
inst✝¹ : AddCommGroup A
inst✝ : Injective (ModuleCat.mk A)
X Y : Bundled AddCommGroup
g : X ⟶ Bundled.mk A
f : X ⟶ Y
m : Mono f
G : ModuleCat.mk ↑X ⟶ ModuleCat.mk A :=
  {
    toAddHom :=
      { toFun := g.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := g.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := g.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑g) (x + y) = ZeroHom.toFun (↑g) x + ZeroHom.toFun (↑g) y) }
                x) }
F : ModuleCat.mk ↑X ⟶ ModuleCat.mk ↑Y :=
  {
    toAddHom :=
      { toFun := f.toFun,
        map_add' := (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) },
    map_smul' :=
      (_ :
        ∀ (r : ℤ) (x : ↑(ModuleCat.mk ↑X)),
          AddHom.toFun
              { toFun := f.toFun,
                map_add' :=
                  (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
              (r • x) =
            ↑(RingHom.id ℤ) r •
              AddHom.toFun
                { toFun := f.toFun,
                  map_add' :=
                    (_ : ∀ (x y : ↑X), ZeroHom.toFun (↑f) (x + y) = ZeroHom.toFun (↑f) x + ZeroHom.toFun (↑f) y) }
                x) }
Z : ModuleCat ℤ
α β : Z ⟶ ModuleCat.mk ↑X
eq1 : α ≫ F = β ≫ F
α' : of ↑Z ⟶ X := LinearMap.toAddMonoidHom α
β' : of ↑Z ⟶ X := LinearMap.toAddMonoidHom β
x : ↑(of ↑Z)
⊢ ↑(LinearMap.toAddMonoidHom α ≫ f) x = ↑(LinearMap.toAddMonoidHom β ≫ f) x