l3lab/ntp-mathlib huggingface dataset:
instance : Preadditive (Action V G) where
  homGroup X Y :=
    { add := fun f g => ⟨f.hom + g.hom, by simp [f.comm, g.comm]⟩
      neg := fun f => ⟨-f.hom, by simp [f.comm]⟩
      zero_add := by intros; ext; exact zero_add _
      add_zero := by intros; ext; exact add_zero _
      add_assoc := by 

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : Preadditive V
X Y : Action V G
⊢ ∀ (a b c : X ⟶ Y), a + b + c = a + (b + c)

Next tactic:
intros
instance : Preadditive (Action V G) where
  homGroup X Y :=
    { add := fun f g => ⟨f.hom + g.hom, by simp [f.comm, g.comm]⟩
      neg := fun f => ⟨-f.hom, by simp [f.comm]⟩
      zero_add := by intros; ext; exact zero_add _
      add_zero := by intros; ext; exact add_zero _
      add_assoc := by intros; 

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : Preadditive V
X Y : Action V G
a✝ b✝ c✝ : X ⟶ Y
⊢ a✝ + b✝ + c✝ = a✝ + (b✝ + c✝)

Next tactic:
ext
instance : Preadditive (Action V G) where
  homGroup X Y :=
    { add := fun f g => ⟨f.hom + g.hom, by simp [f.comm, g.comm]⟩
      neg := fun f => ⟨-f.hom, by simp [f.comm]⟩
      zero_add := by intros; ext; exact zero_add _
      add_zero := by intros; ext; exact add_zero _
      add_assoc := by intros; ext; 

Proof state:
case h
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : Preadditive V
X Y : Action V G
a✝ b✝ c✝ : X ⟶ Y
⊢ (a✝ + b✝ + c✝).hom = (a✝ + (b✝ + c✝)).hom

Next tactic:
exact add_assoc _ _ _
instance : Preadditive (Action V G) where
  homGroup X Y :=
    { add := fun f g => ⟨f.hom + g.hom, by simp [f.comm, g.comm]⟩
      neg := fun f => ⟨-f.hom, by simp [f.comm]⟩
      zero_add := by 

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : Preadditive V
X Y : Action V G
⊢ ∀ (a : X ⟶ Y), 0 + a = a

Next tactic:
intros
instance : Preadditive (Action V G) where
  homGroup X Y :=
    { add := fun f g => ⟨f.hom + g.hom, by simp [f.comm, g.comm]⟩
      neg := fun f => ⟨-f.hom, by simp [f.comm]⟩
      zero_add := by intros; 

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : Preadditive V
X Y : Action V G
a✝ : X ⟶ Y
⊢ 0 + a✝ = a✝

Next tactic:
ext
instance : Preadditive (Action V G) where
  homGroup X Y :=
    { add := fun f g => ⟨f.hom + g.hom, by simp [f.comm, g.comm]⟩
      neg := fun f => ⟨-f.hom, by simp [f.comm]⟩
      zero_add := by intros; ext; 

Proof state:
case h
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : Preadditive V
X Y : Action V G
a✝ : X ⟶ Y
⊢ (0 + a✝).hom = a✝.hom

Next tactic:
exact zero_add _
instance : Preadditive (Action V G) where
  homGroup X Y :=
    { add := fun f g => ⟨f.hom + g.hom, by simp [f.comm, g.comm]⟩
      neg := fun f => ⟨-f.hom, by simp [f.comm]⟩
      zero_add := by intros; ext; exact zero_add _
      add_zero := by 

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : Preadditive V
X Y : Action V G
⊢ ∀ (a : X ⟶ Y), a + 0 = a

Next tactic:
intros
instance : Preadditive (Action V G) where
  homGroup X Y :=
    { add := fun f g => ⟨f.hom + g.hom, by simp [f.comm, g.comm]⟩
      neg := fun f => ⟨-f.hom, by simp [f.comm]⟩
      zero_add := by intros; ext; exact zero_add _
      add_zero := by intros; 

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : Preadditive V
X Y : Action V G
a✝ : X ⟶ Y
⊢ a✝ + 0 = a✝

Next tactic:
ext
instance : Preadditive (Action V G) where
  homGroup X Y :=
    { add := fun f g => ⟨f.hom + g.hom, by simp [f.comm, g.comm]⟩
      neg := fun f => ⟨-f.hom, by simp [f.comm]⟩
      zero_add := by intros; ext; exact zero_add _
      add_zero := by intros; ext; 

Proof state:
case h
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : Preadditive V
X Y : Action V G
a✝ : X ⟶ Y
⊢ (a✝ + 0).hom = a✝.hom

Next tactic:
exact add_zero _
instance : Preadditive (Action V G) where
  homGroup X Y :=
    { add := fun f g => ⟨f.hom + g.hom, by simp [f.comm, g.comm]⟩
      neg := fun f => ⟨-f.hom, by 

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : Preadditive V
X Y : Action V G
f : X ⟶ Y
⊢ ∀ (g : ↑G), X.ρ g ≫ (-f.hom) = (-f.hom) ≫ Y.ρ g

Next tactic:
simp [f.comm]
instance : Preadditive (Action V G) where
  homGroup X Y :=
    { add := fun f g => ⟨f.hom + g.hom, by simp [f.comm, g.comm]⟩
      neg := fun f => ⟨-f.hom, by simp [f.comm]⟩
      zero_add := by intros; ext; exact zero_add _
      add_zero := by intros; ext; exact add_zero _
      add_assoc := by intros; ext; exact add_assoc _ _ _
      add_left_neg := by 

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : Preadditive V
X Y : Action V G
⊢ ∀ (a : X ⟶ Y), -a + a = 0

Next tactic:
intros
instance : Preadditive (Action V G) where
  homGroup X Y :=
    { add := fun f g => ⟨f.hom + g.hom, by simp [f.comm, g.comm]⟩
      neg := fun f => ⟨-f.hom, by simp [f.comm]⟩
      zero_add := by intros; ext; exact zero_add _
      add_zero := by intros; ext; exact add_zero _
      add_assoc := by intros; ext; exact add_assoc _ _ _
      add_left_neg := by intros; 

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : Preadditive V
X Y : Action V G
a✝ : X ⟶ Y
⊢ -a✝ + a✝ = 0

Next tactic:
ext
instance : Preadditive (Action V G) where
  homGroup X Y :=
    { add := fun f g => ⟨f.hom + g.hom, by simp [f.comm, g.comm]⟩
      neg := fun f => ⟨-f.hom, by simp [f.comm]⟩
      zero_add := by intros; ext; exact zero_add _
      add_zero := by intros; ext; exact add_zero _
      add_assoc := by intros; ext; exact add_assoc _ _ _
      add_left_neg := by intros; ext; 

Proof state:
case h
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : Preadditive V
X Y : Action V G
a✝ : X ⟶ Y
⊢ (-a✝ + a✝).hom = 0.hom

Next tactic:
exact add_left_neg _
instance : Preadditive (Action V G) where
  homGroup X Y :=
    { add := fun f g => ⟨f.hom + g.hom, by simp [f.comm, g.comm]⟩
      neg := fun f => ⟨-f.hom, by simp [f.comm]⟩
      zero_add := by intros; ext; exact zero_add _
      add_zero := by intros; ext; exact add_zero _
      add_assoc := by intros; ext; exact add_assoc _ _ _
      add_left_neg := by intros; ext; exact add_left_neg _
      add_comm := by 

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : Preadditive V
X Y : Action V G
⊢ ∀ (a b : X ⟶ Y), a + b = b + a

Next tactic:
intros
instance : Preadditive (Action V G) where
  homGroup X Y :=
    { add := fun f g => ⟨f.hom + g.hom, by simp [f.comm, g.comm]⟩
      neg := fun f => ⟨-f.hom, by simp [f.comm]⟩
      zero_add := by intros; ext; exact zero_add _
      add_zero := by intros; ext; exact add_zero _
      add_assoc := by intros; ext; exact add_assoc _ _ _
      add_left_neg := by intros; ext; exact add_left_neg _
      add_comm := by intros; 

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : Preadditive V
X Y : Action V G
a✝ b✝ : X ⟶ Y
⊢ a✝ + b✝ = b✝ + a✝

Next tactic:
ext
instance : Preadditive (Action V G) where
  homGroup X Y :=
    { add := fun f g => ⟨f.hom + g.hom, by simp [f.comm, g.comm]⟩
      neg := fun f => ⟨-f.hom, by simp [f.comm]⟩
      zero_add := by intros; ext; exact zero_add _
      add_zero := by intros; ext; exact add_zero _
      add_assoc := by intros; ext; exact add_assoc _ _ _
      add_left_neg := by intros; ext; exact add_left_neg _
      add_comm := by intros; ext; 

Proof state:
case h
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : Preadditive V
X Y : Action V G
a✝ b✝ : X ⟶ Y
⊢ (a✝ + b✝).hom = (b✝ + a✝).hom

Next tactic:
exact add_comm _ _
instance : Preadditive (Action V G) where
  homGroup X Y :=
    { add := fun f g => ⟨f.hom + g.hom, by simp [f.comm, g.comm]⟩
      neg := fun f => ⟨-f.hom, by simp [f.comm]⟩
      zero_add := by intros; ext; exact zero_add _
      add_zero := by intros; ext; exact add_zero _
      add_assoc := by intros; ext; exact add_assoc _ _ _
      add_left_neg := by intros; ext; exact add_left_neg _
      add_comm := by intros; ext; exact add_comm _ _ }
  add_comp := by 

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : Preadditive V
⊢ ∀ (P Q R : Action V G) (f f' : P ⟶ Q) (g : Q ⟶ R), (f + f') ≫ g = f ≫ g + f' ≫ g

Next tactic:
intros
instance : Preadditive (Action V G) where
  homGroup X Y :=
    { add := fun f g => ⟨f.hom + g.hom, by simp [f.comm, g.comm]⟩
      neg := fun f => ⟨-f.hom, by simp [f.comm]⟩
      zero_add := by intros; ext; exact zero_add _
      add_zero := by intros; ext; exact add_zero _
      add_assoc := by intros; ext; exact add_assoc _ _ _
      add_left_neg := by intros; ext; exact add_left_neg _
      add_comm := by intros; ext; exact add_comm _ _ }
  add_comp := by intros; 

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : Preadditive V
P✝ Q✝ R✝ : Action V G
f✝ f'✝ : P✝ ⟶ Q✝
g✝ : Q✝ ⟶ R✝
⊢ (f✝ + f'✝) ≫ g✝ = f✝ ≫ g✝ + f'✝ ≫ g✝

Next tactic:
ext
instance : Preadditive (Action V G) where
  homGroup X Y :=
    { add := fun f g => ⟨f.hom + g.hom, by simp [f.comm, g.comm]⟩
      neg := fun f => ⟨-f.hom, by simp [f.comm]⟩
      zero_add := by intros; ext; exact zero_add _
      add_zero := by intros; ext; exact add_zero _
      add_assoc := by intros; ext; exact add_assoc _ _ _
      add_left_neg := by intros; ext; exact add_left_neg _
      add_comm := by intros; ext; exact add_comm _ _ }
  add_comp := by intros; ext; 

Proof state:
case h
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : Preadditive V
P✝ Q✝ R✝ : Action V G
f✝ f'✝ : P✝ ⟶ Q✝
g✝ : Q✝ ⟶ R✝
⊢ ((f✝ + f'✝) ≫ g✝).hom = (f✝ ≫ g✝ + f'✝ ≫ g✝).hom

Next tactic:
exact Preadditive.add_comp _ _ _ _ _ _
instance : Preadditive (Action V G) where
  homGroup X Y :=
    { add := fun f g => ⟨f.hom + g.hom, by simp [f.comm, g.comm]⟩
      neg := fun f => ⟨-f.hom, by simp [f.comm]⟩
      zero_add := by intros; ext; exact zero_add _
      add_zero := by intros; ext; exact add_zero _
      add_assoc := by intros; ext; exact add_assoc _ _ _
      add_left_neg := by intros; ext; exact add_left_neg _
      add_comm := by intros; ext; exact add_comm _ _ }
  add_comp := by intros; ext; exact Preadditive.add_comp _ _ _ _ _ _
  comp_add := by 

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : Preadditive V
⊢ ∀ (P Q R : Action V G) (f : P ⟶ Q) (g g' : Q ⟶ R), f ≫ (g + g') = f ≫ g + f ≫ g'

Next tactic:
intros
instance : Preadditive (Action V G) where
  homGroup X Y :=
    { add := fun f g => ⟨f.hom + g.hom, by simp [f.comm, g.comm]⟩
      neg := fun f => ⟨-f.hom, by simp [f.comm]⟩
      zero_add := by intros; ext; exact zero_add _
      add_zero := by intros; ext; exact add_zero _
      add_assoc := by intros; ext; exact add_assoc _ _ _
      add_left_neg := by intros; ext; exact add_left_neg _
      add_comm := by intros; ext; exact add_comm _ _ }
  add_comp := by intros; ext; exact Preadditive.add_comp _ _ _ _ _ _
  comp_add := by intros; 

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : Preadditive V
P✝ Q✝ R✝ : Action V G
f✝ : P✝ ⟶ Q✝
g✝ g'✝ : Q✝ ⟶ R✝
⊢ f✝ ≫ (g✝ + g'✝) = f✝ ≫ g✝ + f✝ ≫ g'✝

Next tactic:
ext
instance : Preadditive (Action V G) where
  homGroup X Y :=
    { add := fun f g => ⟨f.hom + g.hom, by simp [f.comm, g.comm]⟩
      neg := fun f => ⟨-f.hom, by simp [f.comm]⟩
      zero_add := by intros; ext; exact zero_add _
      add_zero := by intros; ext; exact add_zero _
      add_assoc := by intros; ext; exact add_assoc _ _ _
      add_left_neg := by intros; ext; exact add_left_neg _
      add_comm := by intros; ext; exact add_comm _ _ }
  add_comp := by intros; ext; exact Preadditive.add_comp _ _ _ _ _ _
  comp_add := by intros; ext; 

Proof state:
case h
V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : Preadditive V
P✝ Q✝ R✝ : Action V G
f✝ : P✝ ⟶ Q✝
g✝ g'✝ : Q✝ ⟶ R✝
⊢ (f✝ ≫ (g✝ + g'✝)).hom = (f✝ ≫ g✝ + f✝ ≫ g'✝).hom

Next tactic:
exact Preadditive.comp_add _ _ _ _ _ _
instance : Linear R (Action V G) where
  homModule X Y :=
    { smul := fun r f => ⟨r • f.hom, by 

Proof state:
V : Type (u + 1)
inst✝³ : LargeCategory V
G : MonCat
inst✝² : Preadditive V
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Linear R V
X Y : Action V G
r : R
f : X ⟶ Y
⊢ ∀ (g : ↑G), X.ρ g ≫ (r • f.hom) = (r • f.hom) ≫ Y.ρ g

Next tactic:
simp [f.comm]
instance : Linear R (Action V G) where
  homModule X Y :=
    { smul := fun r f => ⟨r • f.hom, by simp [f.comm]⟩
      one_smul := by 

Proof state:
V : Type (u + 1)
inst✝³ : LargeCategory V
G : MonCat
inst✝² : Preadditive V
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Linear R V
X Y : Action V G
⊢ ∀ (b : X ⟶ Y), 1 • b = b

Next tactic:
intros
instance : Linear R (Action V G) where
  homModule X Y :=
    { smul := fun r f => ⟨r • f.hom, by simp [f.comm]⟩
      one_smul := by intros; 

Proof state:
V : Type (u + 1)
inst✝³ : LargeCategory V
G : MonCat
inst✝² : Preadditive V
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Linear R V
X Y : Action V G
b✝ : X ⟶ Y
⊢ 1 • b✝ = b✝

Next tactic:
ext
instance : Linear R (Action V G) where
  homModule X Y :=
    { smul := fun r f => ⟨r • f.hom, by simp [f.comm]⟩
      one_smul := by intros; ext; 

Proof state:
case h
V : Type (u + 1)
inst✝³ : LargeCategory V
G : MonCat
inst✝² : Preadditive V
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Linear R V
X Y : Action V G
b✝ : X ⟶ Y
⊢ (1 • b✝).hom = b✝.hom

Next tactic:
exact one_smul _ _
instance : Linear R (Action V G) where
  homModule X Y :=
    { smul := fun r f => ⟨r • f.hom, by simp [f.comm]⟩
      one_smul := by intros; ext; exact one_smul _ _
      smul_zero := by intros; ext; exact smul_zero _
      zero_smul := by intros; ext; exact zero_smul _ _
      add_smul := by intros; ext; exact add_smul _ _ _
      smul_add := by intros; ext; exact smul_add _ _ _
      mul_smul := by 

Proof state:
V : Type (u + 1)
inst✝³ : LargeCategory V
G : MonCat
inst✝² : Preadditive V
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Linear R V
X Y : Action V G
⊢ ∀ (x y : R) (b : X ⟶ Y), (x * y) • b = x • y • b

Next tactic:
intros
instance : Linear R (Action V G) where
  homModule X Y :=
    { smul := fun r f => ⟨r • f.hom, by simp [f.comm]⟩
      one_smul := by intros; ext; exact one_smul _ _
      smul_zero := by intros; ext; exact smul_zero _
      zero_smul := by intros; ext; exact zero_smul _ _
      add_smul := by intros; ext; exact add_smul _ _ _
      smul_add := by intros; ext; exact smul_add _ _ _
      mul_smul := by intros; 

Proof state:
V : Type (u + 1)
inst✝³ : LargeCategory V
G : MonCat
inst✝² : Preadditive V
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Linear R V
X Y : Action V G
x✝ y✝ : R
b✝ : X ⟶ Y
⊢ (x✝ * y✝) • b✝ = x✝ • y✝ • b✝

Next tactic:
ext
instance : Linear R (Action V G) where
  homModule X Y :=
    { smul := fun r f => ⟨r • f.hom, by simp [f.comm]⟩
      one_smul := by intros; ext; exact one_smul _ _
      smul_zero := by intros; ext; exact smul_zero _
      zero_smul := by intros; ext; exact zero_smul _ _
      add_smul := by intros; ext; exact add_smul _ _ _
      smul_add := by intros; ext; exact smul_add _ _ _
      mul_smul := by intros; ext; 

Proof state:
case h
V : Type (u + 1)
inst✝³ : LargeCategory V
G : MonCat
inst✝² : Preadditive V
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Linear R V
X Y : Action V G
x✝ y✝ : R
b✝ : X ⟶ Y
⊢ ((x✝ * y✝) • b✝).hom = (x✝ • y✝ • b✝).hom

Next tactic:
exact mul_smul _ _ _
instance : Linear R (Action V G) where
  homModule X Y :=
    { smul := fun r f => ⟨r • f.hom, by simp [f.comm]⟩
      one_smul := by intros; ext; exact one_smul _ _
      smul_zero := by 

Proof state:
V : Type (u + 1)
inst✝³ : LargeCategory V
G : MonCat
inst✝² : Preadditive V
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Linear R V
X Y : Action V G
⊢ ∀ (a : R), a • 0 = 0

Next tactic:
intros
instance : Linear R (Action V G) where
  homModule X Y :=
    { smul := fun r f => ⟨r • f.hom, by simp [f.comm]⟩
      one_smul := by intros; ext; exact one_smul _ _
      smul_zero := by intros; 

Proof state:
V : Type (u + 1)
inst✝³ : LargeCategory V
G : MonCat
inst✝² : Preadditive V
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Linear R V
X Y : Action V G
a✝ : R
⊢ a✝ • 0 = 0

Next tactic:
ext
instance : Linear R (Action V G) where
  homModule X Y :=
    { smul := fun r f => ⟨r • f.hom, by simp [f.comm]⟩
      one_smul := by intros; ext; exact one_smul _ _
      smul_zero := by intros; ext; 

Proof state:
case h
V : Type (u + 1)
inst✝³ : LargeCategory V
G : MonCat
inst✝² : Preadditive V
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Linear R V
X Y : Action V G
a✝ : R
⊢ (a✝ • 0).hom = 0.hom

Next tactic:
exact smul_zero _
instance : Linear R (Action V G) where
  homModule X Y :=
    { smul := fun r f => ⟨r • f.hom, by simp [f.comm]⟩
      one_smul := by intros; ext; exact one_smul _ _
      smul_zero := by intros; ext; exact smul_zero _
      zero_smul := by intros; ext; exact zero_smul _ _
      add_smul := by intros; ext; exact add_smul _ _ _
      smul_add := by 

Proof state:
V : Type (u + 1)
inst✝³ : LargeCategory V
G : MonCat
inst✝² : Preadditive V
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Linear R V
X Y : Action V G
⊢ ∀ (a : R) (x y : X ⟶ Y), a • (x + y) = a • x + a • y

Next tactic:
intros
instance : Linear R (Action V G) where
  homModule X Y :=
    { smul := fun r f => ⟨r • f.hom, by simp [f.comm]⟩
      one_smul := by intros; ext; exact one_smul _ _
      smul_zero := by intros; ext; exact smul_zero _
      zero_smul := by intros; ext; exact zero_smul _ _
      add_smul := by intros; ext; exact add_smul _ _ _
      smul_add := by intros; 

Proof state:
V : Type (u + 1)
inst✝³ : LargeCategory V
G : MonCat
inst✝² : Preadditive V
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Linear R V
X Y : Action V G
a✝ : R
x✝ y✝ : X ⟶ Y
⊢ a✝ • (x✝ + y✝) = a✝ • x✝ + a✝ • y✝

Next tactic:
ext
instance : Linear R (Action V G) where
  homModule X Y :=
    { smul := fun r f => ⟨r • f.hom, by simp [f.comm]⟩
      one_smul := by intros; ext; exact one_smul _ _
      smul_zero := by intros; ext; exact smul_zero _
      zero_smul := by intros; ext; exact zero_smul _ _
      add_smul := by intros; ext; exact add_smul _ _ _
      smul_add := by intros; ext; 

Proof state:
case h
V : Type (u + 1)
inst✝³ : LargeCategory V
G : MonCat
inst✝² : Preadditive V
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Linear R V
X Y : Action V G
a✝ : R
x✝ y✝ : X ⟶ Y
⊢ (a✝ • (x✝ + y✝)).hom = (a✝ • x✝ + a✝ • y✝).hom

Next tactic:
exact smul_add _ _ _
instance : Linear R (Action V G) where
  homModule X Y :=
    { smul := fun r f => ⟨r • f.hom, by simp [f.comm]⟩
      one_smul := by intros; ext; exact one_smul _ _
      smul_zero := by intros; ext; exact smul_zero _
      zero_smul := by intros; ext; exact zero_smul _ _
      add_smul := by 

Proof state:
V : Type (u + 1)
inst✝³ : LargeCategory V
G : MonCat
inst✝² : Preadditive V
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Linear R V
X Y : Action V G
⊢ ∀ (r s : R) (x : X ⟶ Y), (r + s) • x = r • x + s • x

Next tactic:
intros
instance : Linear R (Action V G) where
  homModule X Y :=
    { smul := fun r f => ⟨r • f.hom, by simp [f.comm]⟩
      one_smul := by intros; ext; exact one_smul _ _
      smul_zero := by intros; ext; exact smul_zero _
      zero_smul := by intros; ext; exact zero_smul _ _
      add_smul := by intros; 

Proof state:
V : Type (u + 1)
inst✝³ : LargeCategory V
G : MonCat
inst✝² : Preadditive V
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Linear R V
X Y : Action V G
r✝ s✝ : R
x✝ : X ⟶ Y
⊢ (r✝ + s✝) • x✝ = r✝ • x✝ + s✝ • x✝

Next tactic:
ext
instance : Linear R (Action V G) where
  homModule X Y :=
    { smul := fun r f => ⟨r • f.hom, by simp [f.comm]⟩
      one_smul := by intros; ext; exact one_smul _ _
      smul_zero := by intros; ext; exact smul_zero _
      zero_smul := by intros; ext; exact zero_smul _ _
      add_smul := by intros; ext; 

Proof state:
case h
V : Type (u + 1)
inst✝³ : LargeCategory V
G : MonCat
inst✝² : Preadditive V
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Linear R V
X Y : Action V G
r✝ s✝ : R
x✝ : X ⟶ Y
⊢ ((r✝ + s✝) • x✝).hom = (r✝ • x✝ + s✝ • x✝).hom

Next tactic:
exact add_smul _ _ _
instance : Linear R (Action V G) where
  homModule X Y :=
    { smul := fun r f => ⟨r • f.hom, by simp [f.comm]⟩
      one_smul := by intros; ext; exact one_smul _ _
      smul_zero := by intros; ext; exact smul_zero _
      zero_smul := by 

Proof state:
V : Type (u + 1)
inst✝³ : LargeCategory V
G : MonCat
inst✝² : Preadditive V
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Linear R V
X Y : Action V G
⊢ ∀ (x : X ⟶ Y), 0 • x = 0

Next tactic:
intros
instance : Linear R (Action V G) where
  homModule X Y :=
    { smul := fun r f => ⟨r • f.hom, by simp [f.comm]⟩
      one_smul := by intros; ext; exact one_smul _ _
      smul_zero := by intros; ext; exact smul_zero _
      zero_smul := by intros; 

Proof state:
V : Type (u + 1)
inst✝³ : LargeCategory V
G : MonCat
inst✝² : Preadditive V
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Linear R V
X Y : Action V G
x✝ : X ⟶ Y
⊢ 0 • x✝ = 0

Next tactic:
ext
instance : Linear R (Action V G) where
  homModule X Y :=
    { smul := fun r f => ⟨r • f.hom, by simp [f.comm]⟩
      one_smul := by intros; ext; exact one_smul _ _
      smul_zero := by intros; ext; exact smul_zero _
      zero_smul := by intros; ext; 

Proof state:
case h
V : Type (u + 1)
inst✝³ : LargeCategory V
G : MonCat
inst✝² : Preadditive V
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Linear R V
X Y : Action V G
x✝ : X ⟶ Y
⊢ (0 • x✝).hom = 0.hom

Next tactic:
exact zero_smul _ _
instance : Linear R (Action V G) where
  homModule X Y :=
    { smul := fun r f => ⟨r • f.hom, by simp [f.comm]⟩
      one_smul := by intros; ext; exact one_smul _ _
      smul_zero := by intros; ext; exact smul_zero _
      zero_smul := by intros; ext; exact zero_smul _ _
      add_smul := by intros; ext; exact add_smul _ _ _
      smul_add := by intros; ext; exact smul_add _ _ _
      mul_smul := by intros; ext; exact mul_smul _ _ _ }
  smul_comp := by 

Proof state:
V : Type (u + 1)
inst✝³ : LargeCategory V
G : MonCat
inst✝² : Preadditive V
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Linear R V
⊢ ∀ (X Y Z : Action V G) (r : R) (f : X ⟶ Y) (g : Y ⟶ Z), (r • f) ≫ g = r • f ≫ g

Next tactic:
intros
instance : Linear R (Action V G) where
  homModule X Y :=
    { smul := fun r f => ⟨r • f.hom, by simp [f.comm]⟩
      one_smul := by intros; ext; exact one_smul _ _
      smul_zero := by intros; ext; exact smul_zero _
      zero_smul := by intros; ext; exact zero_smul _ _
      add_smul := by intros; ext; exact add_smul _ _ _
      smul_add := by intros; ext; exact smul_add _ _ _
      mul_smul := by intros; ext; exact mul_smul _ _ _ }
  smul_comp := by intros; 

Proof state:
V : Type (u + 1)
inst✝³ : LargeCategory V
G : MonCat
inst✝² : Preadditive V
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Linear R V
X✝ Y✝ Z✝ : Action V G
r✝ : R
f✝ : X✝ ⟶ Y✝
g✝ : Y✝ ⟶ Z✝
⊢ (r✝ • f✝) ≫ g✝ = r✝ • f✝ ≫ g✝

Next tactic:
ext
instance : Linear R (Action V G) where
  homModule X Y :=
    { smul := fun r f => ⟨r • f.hom, by simp [f.comm]⟩
      one_smul := by intros; ext; exact one_smul _ _
      smul_zero := by intros; ext; exact smul_zero _
      zero_smul := by intros; ext; exact zero_smul _ _
      add_smul := by intros; ext; exact add_smul _ _ _
      smul_add := by intros; ext; exact smul_add _ _ _
      mul_smul := by intros; ext; exact mul_smul _ _ _ }
  smul_comp := by intros; ext; 

Proof state:
case h
V : Type (u + 1)
inst✝³ : LargeCategory V
G : MonCat
inst✝² : Preadditive V
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Linear R V
X✝ Y✝ Z✝ : Action V G
r✝ : R
f✝ : X✝ ⟶ Y✝
g✝ : Y✝ ⟶ Z✝
⊢ ((r✝ • f✝) ≫ g✝).hom = (r✝ • f✝ ≫ g✝).hom

Next tactic:
exact Linear.smul_comp _ _ _ _ _ _
instance : Linear R (Action V G) where
  homModule X Y :=
    { smul := fun r f => ⟨r • f.hom, by simp [f.comm]⟩
      one_smul := by intros; ext; exact one_smul _ _
      smul_zero := by intros; ext; exact smul_zero _
      zero_smul := by intros; ext; exact zero_smul _ _
      add_smul := by intros; ext; exact add_smul _ _ _
      smul_add := by intros; ext; exact smul_add _ _ _
      mul_smul := by intros; ext; exact mul_smul _ _ _ }
  smul_comp := by intros; ext; exact Linear.smul_comp _ _ _ _ _ _
  comp_smul := by 

Proof state:
V : Type (u + 1)
inst✝³ : LargeCategory V
G : MonCat
inst✝² : Preadditive V
R : Type u_1
inst✝¹ : Semiring R
inst✝ : Linear R V
⊢ ∀ (X Y Z : Action V G) (f : X ⟶ Y) (r : R) (g : Y ⟶ Z), f ≫ (r • g) = r • f ≫ g

Next tactic:
intros