l3lab/ntp-mathlib huggingface dataset:
@[simp]
lemma shiftFunctorZero_inv_app_obj_of_induced (X : C) :
    letI := HasShift.induced F A s i hF
    (shiftFunctorZero D A).inv.app (F.obj X) =
      F.map ((shiftFunctorZero C A).inv.app X) ≫ (i 0).inv.app X := by
  

Proof state:
C : Type u_4
D : Type u_2
inst✝³ : Category.{u_3, u_4} C
inst✝² : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_5
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
X : C
⊢ (shiftFunctorZero D A).inv.app (F.obj X) = F.map ((shiftFunctorZero C A).inv.app X) ≫ (i 0).inv.app X

Next tactic:
letI := HasShift.induced F A s i
@[simp]
lemma shiftFunctorZero_inv_app_obj_of_induced (X : C) :
    letI := HasShift.induced F A s i hF
    (shiftFunctorZero D A).inv.app (F.obj X) =
      F.map ((shiftFunctorZero C A).inv.app X) ≫ (i 0).inv.app X := by
  letI := HasShift.induced F A s i
  

Proof state:
C : Type u_4
D : Type u_2
inst✝³ : Category.{u_3, u_4} C
inst✝² : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_5
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
X : C
this : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F) → HasShift D A :=
  HasShift.induced F A s i
⊢ (shiftFunctorZero D A).inv.app (F.obj X) = F.map ((shiftFunctorZero C A).inv.app X) ≫ (i 0).inv.app X

Next tactic:
simp only [ShiftMkCore.shiftFunctorZero_eq, HasShift.Induced.zero_inv_app_obj]
@[simp]
lemma shiftFunctorAdd_hom_app_obj_of_induced (a b : A) (X : C) :
    letI := HasShift.induced F A s i hF
    (shiftFunctorAdd D a b).hom.app (F.obj X) =
      (i (a + b)).hom.app X ≫
        F.map ((shiftFunctorAdd C a b).hom.app X) ≫
        (i b).inv.app ((shiftFunctor C a).obj X) ≫
        (s b).map ((i a).inv.app X) := by
  

Proof state:
C : Type u_4
D : Type u_2
inst✝³ : Category.{u_5, u_4} C
inst✝² : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_3
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
a b : A
X : C
⊢ (shiftFunctorAdd D a b).hom.app (F.obj X) =
    (i (a + b)).hom.app X ≫
      F.map ((shiftFunctorAdd C a b).hom.app X) ≫ (i b).inv.app ((shiftFunctor C a).obj X) ≫ (s b).map ((i a).inv.app X)

Next tactic:
letI := HasShift.induced F A s i
@[simp]
lemma shiftFunctorAdd_hom_app_obj_of_induced (a b : A) (X : C) :
    letI := HasShift.induced F A s i hF
    (shiftFunctorAdd D a b).hom.app (F.obj X) =
      (i (a + b)).hom.app X ≫
        F.map ((shiftFunctorAdd C a b).hom.app X) ≫
        (i b).inv.app ((shiftFunctor C a).obj X) ≫
        (s b).map ((i a).inv.app X) := by
  letI := HasShift.induced F A s i
  

Proof state:
C : Type u_4
D : Type u_2
inst✝³ : Category.{u_5, u_4} C
inst✝² : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_3
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
a b : A
X : C
this : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F) → HasShift D A :=
  HasShift.induced F A s i
⊢ (shiftFunctorAdd D a b).hom.app (F.obj X) =
    (i (a + b)).hom.app X ≫
      F.map ((shiftFunctorAdd C a b).hom.app X) ≫ (i b).inv.app ((shiftFunctor C a).obj X) ≫ (s b).map ((i a).inv.app X)

Next tactic:
simp only [ShiftMkCore.shiftFunctorAdd_eq, HasShift.Induced.add_hom_app_obj]
@[simp]
lemma shiftFunctorAdd_inv_app_obj_of_induced (a b : A) (X : C) :
    letI := HasShift.induced F A s i hF
    (shiftFunctorAdd D a b).inv.app (F.obj X) =
      (s b).map ((i a).hom.app X) ≫
      (i b).hom.app ((shiftFunctor C a).obj X) ≫
      F.map ((shiftFunctorAdd C a b).inv.app X) ≫
      (i (a + b)).inv.app X := by
  

Proof state:
C : Type u_4
D : Type u_2
inst✝³ : Category.{u_5, u_4} C
inst✝² : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_3
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
a b : A
X : C
⊢ (shiftFunctorAdd D a b).inv.app (F.obj X) =
    (s b).map ((i a).hom.app X) ≫
      (i b).hom.app ((shiftFunctor C a).obj X) ≫ F.map ((shiftFunctorAdd C a b).inv.app X) ≫ (i (a + b)).inv.app X

Next tactic:
letI := HasShift.induced F A s i
@[simp]
lemma shiftFunctorAdd_inv_app_obj_of_induced (a b : A) (X : C) :
    letI := HasShift.induced F A s i hF
    (shiftFunctorAdd D a b).inv.app (F.obj X) =
      (s b).map ((i a).hom.app X) ≫
      (i b).hom.app ((shiftFunctor C a).obj X) ≫
      F.map ((shiftFunctorAdd C a b).inv.app X) ≫
      (i (a + b)).inv.app X := by
  letI := HasShift.induced F A s i
  

Proof state:
C : Type u_4
D : Type u_2
inst✝³ : Category.{u_5, u_4} C
inst✝² : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_3
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
a b : A
X : C
this : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F) → HasShift D A :=
  HasShift.induced F A s i
⊢ (shiftFunctorAdd D a b).inv.app (F.obj X) =
    (s b).map ((i a).hom.app X) ≫
      (i b).hom.app ((shiftFunctor C a).obj X) ≫ F.map ((shiftFunctorAdd C a b).inv.app X) ≫ (i (a + b)).inv.app X

Next tactic:
simp only [ShiftMkCore.shiftFunctorAdd_eq, HasShift.Induced.add_inv_app_obj]
/-- When the target category of a functor `F : C ⥤ D` is equipped with
the induced shift, this is the compatibility of `F` with the shifts on
the categories `C` and `D`. -/
def Functor.CommShift.ofInduced :
    letI := HasShift.induced F A s i hF
    F.CommShift A := by
  

Proof state:
C : Type ?u.125746
D : Type ?u.125749
inst✝³ : Category.{?u.125753, ?u.125746} C
inst✝² : Category.{?u.125757, ?u.125749} D
F : C ⥤ D
A : Type ?u.125788
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
⊢ CommShift F A

Next tactic:
letI := HasShift.induced F A s i hF
/-- When the target category of a functor `F : C ⥤ D` is equipped with
the induced shift, this is the compatibility of `F` with the shifts on
the categories `C` and `D`. -/
def Functor.CommShift.ofInduced :
    letI := HasShift.induced F A s i hF
    F.CommShift A := by
  letI := HasShift.induced F A s i hF
  

Proof state:
C : Type ?u.125746
D : Type ?u.125749
inst✝³ : Category.{?u.125753, ?u.125746} C
inst✝² : Category.{?u.125757, ?u.125749} D
F : C ⥤ D
A : Type ?u.125788
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
this : HasShift D A := HasShift.induced F A s i hF
⊢ CommShift F A

Next tactic:
exact
    { iso := fun a => (i a).symm
      zero := by
        ext X
        dsimp
        simp only [isoZero_hom_app, shiftFunctorZero_inv_app_obj_of_induced,
          ← F.map_comp_assoc, Iso.hom_inv_id_app, F.map_id, Category.id_comp]
      add := fun a b => by
        ext X
        dsimp
        simp only [isoAdd_hom_app, Iso.symm_hom, shiftFunctorAdd_inv_app_obj_of_induced,
          shiftFunctor_of_induced]
        erw [← Functor.map_comp_assoc, Iso.inv_hom_id_app, Functor.map_id,
          Category.id_comp, Iso.inv_hom_id_app_assoc, ← F.map_comp_assoc, Iso.hom_inv_id_app,
          F.map_id, Category.id_comp] }
/-- When the target category of a functor `F : C ⥤ D` is equipped with
the induced shift, this is the compatibility of `F` with the shifts on
the categories `C` and `D`. -/
def Functor.CommShift.ofInduced :
    letI := HasShift.induced F A s i hF
    F.CommShift A := by
  letI := HasShift.induced F A s i hF
  exact
    { iso := fun a => (i a).symm
      zero := by
        

Proof state:
C : Type ?u.125746
D : Type ?u.125749
inst✝³ : Category.{?u.125753, ?u.125746} C
inst✝² : Category.{?u.125757, ?u.125749} D
F : C ⥤ D
A : Type ?u.125788
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
this : HasShift D A := HasShift.induced F A s i hF
⊢ (fun a => (i a).symm) 0 = isoZero F A

Next tactic:
ext X
/-- When the target category of a functor `F : C ⥤ D` is equipped with
the induced shift, this is the compatibility of `F` with the shifts on
the categories `C` and `D`. -/
def Functor.CommShift.ofInduced :
    letI := HasShift.induced F A s i hF
    F.CommShift A := by
  letI := HasShift.induced F A s i hF
  exact
    { iso := fun a => (i a).symm
      zero := by
        ext X
        

Proof state:
case w.w.h
C : Type ?u.125746
D : Type ?u.125749
inst✝³ : Category.{?u.125753, ?u.125746} C
inst✝² : Category.{?u.125757, ?u.125749} D
F : C ⥤ D
A : Type ?u.125788
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
this : HasShift D A := HasShift.induced F A s i hF
X : C
⊢ ((fun a => (i a).symm) 0).hom.app X = (isoZero F A).hom.app X

Next tactic:
dsimp
/-- When the target category of a functor `F : C ⥤ D` is equipped with
the induced shift, this is the compatibility of `F` with the shifts on
the categories `C` and `D`. -/
def Functor.CommShift.ofInduced :
    letI := HasShift.induced F A s i hF
    F.CommShift A := by
  letI := HasShift.induced F A s i hF
  exact
    { iso := fun a => (i a).symm
      zero := by
        ext X
        dsimp
        

Proof state:
case w.w.h
C : Type ?u.125746
D : Type ?u.125749
inst✝³ : Category.{?u.125753, ?u.125746} C
inst✝² : Category.{?u.125757, ?u.125749} D
F : C ⥤ D
A : Type ?u.125788
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
this : HasShift D A := HasShift.induced F A s i hF
X : C
⊢ (i 0).inv.app X = (isoZero F A).hom.app X

Next tactic:
simp only [isoZero_hom_app, shiftFunctorZero_inv_app_obj_of_induced,
          ← F.map_comp_assoc, Iso.hom_inv_id_app, F.map_id, Category.id_comp]
/-- When the target category of a functor `F : C ⥤ D` is equipped with
the induced shift, this is the compatibility of `F` with the shifts on
the categories `C` and `D`. -/
def Functor.CommShift.ofInduced :
    letI := HasShift.induced F A s i hF
    F.CommShift A := by
  letI := HasShift.induced F A s i hF
  exact
    { iso := fun a => (i a).symm
      zero := by
        ext X
        dsimp
        simp only [isoZero_hom_app, shiftFunctorZero_inv_app_obj_of_induced,
          ← F.map_comp_assoc, Iso.hom_inv_id_app, F.map_id, Category.id_comp]
      add := fun a b => by
        

Proof state:
C : Type ?u.125746
D : Type ?u.125749
inst✝³ : Category.{?u.125753, ?u.125746} C
inst✝² : Category.{?u.125757, ?u.125749} D
F : C ⥤ D
A : Type ?u.125788
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
this : HasShift D A := HasShift.induced F A s i hF
a b : A
⊢ (fun a => (i a).symm) (a + b) = isoAdd ((fun a => (i a).symm) a) ((fun a => (i a).symm) b)

Next tactic:
ext X
/-- When the target category of a functor `F : C ⥤ D` is equipped with
the induced shift, this is the compatibility of `F` with the shifts on
the categories `C` and `D`. -/
def Functor.CommShift.ofInduced :
    letI := HasShift.induced F A s i hF
    F.CommShift A := by
  letI := HasShift.induced F A s i hF
  exact
    { iso := fun a => (i a).symm
      zero := by
        ext X
        dsimp
        simp only [isoZero_hom_app, shiftFunctorZero_inv_app_obj_of_induced,
          ← F.map_comp_assoc, Iso.hom_inv_id_app, F.map_id, Category.id_comp]
      add := fun a b => by
        ext X
        

Proof state:
case w.w.h
C : Type ?u.125746
D : Type ?u.125749
inst✝³ : Category.{?u.125753, ?u.125746} C
inst✝² : Category.{?u.125757, ?u.125749} D
F : C ⥤ D
A : Type ?u.125788
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
this : HasShift D A := HasShift.induced F A s i hF
a b : A
X : C
⊢ ((fun a => (i a).symm) (a + b)).hom.app X = (isoAdd ((fun a => (i a).symm) a) ((fun a => (i a).symm) b)).hom.app X

Next tactic:
dsimp
/-- When the target category of a functor `F : C ⥤ D` is equipped with
the induced shift, this is the compatibility of `F` with the shifts on
the categories `C` and `D`. -/
def Functor.CommShift.ofInduced :
    letI := HasShift.induced F A s i hF
    F.CommShift A := by
  letI := HasShift.induced F A s i hF
  exact
    { iso := fun a => (i a).symm
      zero := by
        ext X
        dsimp
        simp only [isoZero_hom_app, shiftFunctorZero_inv_app_obj_of_induced,
          ← F.map_comp_assoc, Iso.hom_inv_id_app, F.map_id, Category.id_comp]
      add := fun a b => by
        ext X
        dsimp
        

Proof state:
case w.w.h
C : Type ?u.125746
D : Type ?u.125749
inst✝³ : Category.{?u.125753, ?u.125746} C
inst✝² : Category.{?u.125757, ?u.125749} D
F : C ⥤ D
A : Type ?u.125788
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
this : HasShift D A := HasShift.induced F A s i hF
a b : A
X : C
⊢ (i (a + b)).inv.app X = (isoAdd (i a).symm (i b).symm).hom.app X

Next tactic:
simp only [isoAdd_hom_app, Iso.symm_hom, shiftFunctorAdd_inv_app_obj_of_induced,
          shiftFunctor_of_induced]
/-- When the target category of a functor `F : C ⥤ D` is equipped with
the induced shift, this is the compatibility of `F` with the shifts on
the categories `C` and `D`. -/
def Functor.CommShift.ofInduced :
    letI := HasShift.induced F A s i hF
    F.CommShift A := by
  letI := HasShift.induced F A s i hF
  exact
    { iso := fun a => (i a).symm
      zero := by
        ext X
        dsimp
        simp only [isoZero_hom_app, shiftFunctorZero_inv_app_obj_of_induced,
          ← F.map_comp_assoc, Iso.hom_inv_id_app, F.map_id, Category.id_comp]
      add := fun a b => by
        ext X
        dsimp
        simp only [isoAdd_hom_app, Iso.symm_hom, shiftFunctorAdd_inv_app_obj_of_induced,
          shiftFunctor_of_induced]
        

Proof state:
case w.w.h
C : Type ?u.125746
D : Type ?u.125749
inst✝³ : Category.{?u.125753, ?u.125746} C
inst✝² : Category.{?u.125757, ?u.125749} D
F : C ⥤ D
A : Type ?u.125788
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
this : HasShift D A := HasShift.induced F A s i hF
a b : A
X : C
⊢ (i (a + b)).inv.app X =
    F.map ((shiftFunctorAdd C a b).hom.app X) ≫
      (i b).inv.app ((shiftFunctor C a).obj X) ≫
        (s b).map ((i a).inv.app X) ≫
          (s b).map ((i a).hom.app X) ≫
            (i b).hom.app ((shiftFunctor C a).obj X) ≫ F.map ((shiftFunctorAdd C a b).inv.app X) ≫ (i (a + b)).inv.app X

Next tactic:
erw [← Functor.map_comp_assoc, Iso.inv_hom_id_app, Functor.map_id,
          Category.id_comp, Iso.inv_hom_id_app_assoc, ← F.map_comp_assoc, Iso.hom_inv_id_app,
          F.map_id, Category.id_comp]
@[to_additive]
instance semigroup [∀ i, Semigroup <| f i] : Semigroup (∀ i : I, f i) :=
  { mul := (· * ·)
    --pi_instance
    mul_assoc := by 

Proof state:
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x y : (i : I) → f i
i j : I
inst✝ : (i : I) → Semigroup (f i)
⊢ ∀ (a b c : (i : I) → f i), a * b * c = a * (b * c)

Next tactic:
intros
@[to_additive]
instance semigroup [∀ i, Semigroup <| f i] : Semigroup (∀ i : I, f i) :=
  { mul := (· * ·)
    --pi_instance
    mul_assoc := by intros; 

Proof state:
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x y : (i : I) → f i
i j : I
inst✝ : (i : I) → Semigroup (f i)
a✝ b✝ c✝ : (i : I) → f i
⊢ a✝ * b✝ * c✝ = a✝ * (b✝ * c✝)

Next tactic:
ext
@[to_additive]
instance semigroup [∀ i, Semigroup <| f i] : Semigroup (∀ i : I, f i) :=
  { mul := (· * ·)
    --pi_instance
    mul_assoc := by intros; ext; 

Proof state:
case h
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x y : (i : I) → f i
i j : I
inst✝ : (i : I) → Semigroup (f i)
a✝ b✝ c✝ : (i : I) → f i
x✝ : I
⊢ (a✝ * b✝ * c✝) x✝ = (a✝ * (b✝ * c✝)) x✝

Next tactic:
exact mul_assoc _ _ _
@[to_additive]
instance commSemigroup [∀ i, CommSemigroup <| f i] : CommSemigroup (∀ i : I, f i) :=
  { semigroup with
    --pi_instance
    mul_comm := by 

Proof state:
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x y : (i : I) → f i
i j : I
inst✝ : (i : I) → CommSemigroup (f i)
src✝ : Semigroup ((i : I) → f i) := semigroup
⊢ ∀ (a b : (i : I) → f i), a * b = b * a

Next tactic:
intros
@[to_additive]
instance commSemigroup [∀ i, CommSemigroup <| f i] : CommSemigroup (∀ i : I, f i) :=
  { semigroup with
    --pi_instance
    mul_comm := by intros; 

Proof state:
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x y : (i : I) → f i
i j : I
inst✝ : (i : I) → CommSemigroup (f i)
src✝ : Semigroup ((i : I) → f i) := semigroup
a✝ b✝ : (i : I) → f i
⊢ a✝ * b✝ = b✝ * a✝

Next tactic:
ext
@[to_additive]
instance commSemigroup [∀ i, CommSemigroup <| f i] : CommSemigroup (∀ i : I, f i) :=
  { semigroup with
    --pi_instance
    mul_comm := by intros; ext; 

Proof state:
case h
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x y : (i : I) → f i
i j : I
inst✝ : (i : I) → CommSemigroup (f i)
src✝ : Semigroup ((i : I) → f i) := semigroup
a✝ b✝ : (i : I) → f i
x✝ : I
⊢ (a✝ * b✝) x✝ = (b✝ * a✝) x✝

Next tactic:
exact mul_comm _ _
@[to_additive]
instance mulOneClass [∀ i, MulOneClass <| f i] : MulOneClass (∀ i : I, f i) :=
  { one := (1 : ∀ i, f i)
    mul := (· * ·)
    --pi_instance
    one_mul := by 

Proof state:
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x y : (i : I) → f i
i j : I
inst✝ : (i : I) → MulOneClass (f i)
⊢ ∀ (a : (i : I) → f i), 1 * a = a

Next tactic:
intros
@[to_additive]
instance mulOneClass [∀ i, MulOneClass <| f i] : MulOneClass (∀ i : I, f i) :=
  { one := (1 : ∀ i, f i)
    mul := (· * ·)
    --pi_instance
    one_mul := by intros; 

Proof state:
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x y : (i : I) → f i
i j : I
inst✝ : (i : I) → MulOneClass (f i)
a✝ : (i : I) → f i
⊢ 1 * a✝ = a✝

Next tactic:
ext
@[to_additive]
instance mulOneClass [∀ i, MulOneClass <| f i] : MulOneClass (∀ i : I, f i) :=
  { one := (1 : ∀ i, f i)
    mul := (· * ·)
    --pi_instance
    one_mul := by intros; ext; 

Proof state:
case h
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x y : (i : I) → f i
i j : I
inst✝ : (i : I) → MulOneClass (f i)
a✝ : (i : I) → f i
x✝ : I
⊢ (1 * a✝) x✝ = a✝ x✝

Next tactic:
exact one_mul _
@[to_additive]
instance mulOneClass [∀ i, MulOneClass <| f i] : MulOneClass (∀ i : I, f i) :=
  { one := (1 : ∀ i, f i)
    mul := (· * ·)
    --pi_instance
    one_mul := by intros; ext; exact one_mul _
    mul_one := by 

Proof state:
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x y : (i : I) → f i
i j : I
inst✝ : (i : I) → MulOneClass (f i)
⊢ ∀ (a : (i : I) → f i), a * 1 = a

Next tactic:
intros
@[to_additive]
instance mulOneClass [∀ i, MulOneClass <| f i] : MulOneClass (∀ i : I, f i) :=
  { one := (1 : ∀ i, f i)
    mul := (· * ·)
    --pi_instance
    one_mul := by intros; ext; exact one_mul _
    mul_one := by intros; 

Proof state:
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x y : (i : I) → f i
i j : I
inst✝ : (i : I) → MulOneClass (f i)
a✝ : (i : I) → f i
⊢ a✝ * 1 = a✝

Next tactic:
ext
@[to_additive]
instance mulOneClass [∀ i, MulOneClass <| f i] : MulOneClass (∀ i : I, f i) :=
  { one := (1 : ∀ i, f i)
    mul := (· * ·)
    --pi_instance
    one_mul := by intros; ext; exact one_mul _
    mul_one := by intros; ext; 

Proof state:
case h
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x y : (i : I) → f i
i j : I
inst✝ : (i : I) → MulOneClass (f i)
a✝ : (i : I) → f i
x✝ : I
⊢ (a✝ * 1) x✝ = a✝ x✝

Next tactic:
exact mul_one _
@[to_additive]
instance invOneClass [∀ i, InvOneClass <| f i] : InvOneClass (∀ i : I, f i) :=
  { one := (1 : ∀ i, f i)
    inv := (· ⁻¹)
    inv_one := by 

Proof state:
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x y : (i : I) → f i
i j : I
inst✝ : (i : I) → InvOneClass (f i)
⊢ 1⁻¹ = 1

Next tactic:
intros
@[to_additive]
instance invOneClass [∀ i, InvOneClass <| f i] : InvOneClass (∀ i : I, f i) :=
  { one := (1 : ∀ i, f i)
    inv := (· ⁻¹)
    inv_one := by intros; 

Proof state:
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x y : (i : I) → f i
i j : I
inst✝ : (i : I) → InvOneClass (f i)
⊢ 1⁻¹ = 1

Next tactic:
ext
@[to_additive]
instance invOneClass [∀ i, InvOneClass <| f i] : InvOneClass (∀ i : I, f i) :=
  { one := (1 : ∀ i, f i)
    inv := (· ⁻¹)
    inv_one := by intros; ext; 

Proof state:
case h
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x y : (i : I) → f i
i j : I
inst✝ : (i : I) → InvOneClass (f i)
x✝ : I
⊢ 1⁻¹ x✝ = OfNat.ofNat 1 x✝

Next tactic:
exact inv_one
@[to_additive]
instance monoid [∀ i, Monoid <| f i] : Monoid (∀ i : I, f i) :=
  { semigroup, mulOneClass with
    npow := fun n x i => x i ^ n
    --pi_instance
    npow_zero := by 

Proof state:
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x y : (i : I) → f i
i j : I
inst✝ : (i : I) → Monoid (f i)
src✝¹ : Semigroup ((i : I) → f i) := semigroup
src✝ : MulOneClass ((i : I) → f i) := mulOneClass
⊢ ∀ (x : (i : I) → f i), (fun n x i => x i ^ n) 0 x = 1

Next tactic:
intros
@[to_additive]
instance monoid [∀ i, Monoid <| f i] : Monoid (∀ i : I, f i) :=
  { semigroup, mulOneClass with
    npow := fun n x i => x i ^ n
    --pi_instance
    npow_zero := by intros; 

Proof state:
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x y : (i : I) → f i
i j : I
inst✝ : (i : I) → Monoid (f i)
src✝¹ : Semigroup ((i : I) → f i) := semigroup
src✝ : MulOneClass ((i : I) → f i) := mulOneClass
x✝ : (i : I) → f i
⊢ (fun n x i => x i ^ n) 0 x✝ = 1

Next tactic:
ext
@[to_additive]
instance monoid [∀ i, Monoid <| f i] : Monoid (∀ i : I, f i) :=
  { semigroup, mulOneClass with
    npow := fun n x i => x i ^ n
    --pi_instance
    npow_zero := by intros; ext; 

Proof state:
case h
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x y : (i : I) → f i
i j : I
inst✝ : (i : I) → Monoid (f i)
src✝¹ : Semigroup ((i : I) → f i) := semigroup
src✝ : MulOneClass ((i : I) → f i) := mulOneClass
x✝¹ : (i : I) → f i
x✝ : I
⊢ (fun n x i => x i ^ n) 0 x✝¹ x✝ = OfNat.ofNat 1 x✝

Next tactic:
exact Monoid.npow_zero _
@[to_additive]
instance monoid [∀ i, Monoid <| f i] : Monoid (∀ i : I, f i) :=
  { semigroup, mulOneClass with
    npow := fun n x i => x i ^ n
    --pi_instance
    npow_zero := by intros; ext; exact Monoid.npow_zero _
    npow_succ := by 

Proof state:
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x y : (i : I) → f i
i j : I
inst✝ : (i : I) → Monoid (f i)
src✝¹ : Semigroup ((i : I) → f i) := semigroup
src✝ : MulOneClass ((i : I) → f i) := mulOneClass
⊢ ∀ (n : ℕ) (x : (i : I) → f i), (fun n x i => x i ^ n) (n + 1) x = x * (fun n x i => x i ^ n) n x

Next tactic:
intros
@[to_additive]
instance monoid [∀ i, Monoid <| f i] : Monoid (∀ i : I, f i) :=
  { semigroup, mulOneClass with
    npow := fun n x i => x i ^ n
    --pi_instance
    npow_zero := by intros; ext; exact Monoid.npow_zero _
    npow_succ := by intros; 

Proof state:
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x y : (i : I) → f i
i j : I
inst✝ : (i : I) → Monoid (f i)
src✝¹ : Semigroup ((i : I) → f i) := semigroup
src✝ : MulOneClass ((i : I) → f i) := mulOneClass
n✝ : ℕ
x✝ : (i : I) → f i
⊢ (fun n x i => x i ^ n) (n✝ + 1) x✝ = x✝ * (fun n x i => x i ^ n) n✝ x✝

Next tactic:
ext