[GOAL]
B : Type u₁
inst✝⁵ : Quiver B
inst✝⁴ : (a b : B) → Quiver (a ⟶ b)
C : Type u₂
inst✝³ : Quiver C
inst✝² : (a b : C) → Quiver (a ⟶ b)
D : Type u₃
inst✝¹ : Quiver D
inst✝ : (a b : D) → Quiver (a ⟶ b)
F✝ F : PrelaxFunctor B C
G : PrelaxFunctor C D
src✝ : B ⥤q D := ↑F ⋙q ↑G
a✝ b✝ : B
f✝ g✝ : a✝ ⟶ b✝
η : f✝ ⟶ g✝
⊢ { obj := src✝.obj, map := fun {X Y} => src✝.map }.map f✝ ⟶ { obj := src✝.obj, map := fun {X Y} => src✝.map }.map g✝
[PROOFSTEP]
exact G.map₂ (F.map₂ η)
[GOAL]
B : Type u₁
inst✝² : Bicategory B
C : Type u₂
inst✝¹ : Bicategory C
D : Type u₃
inst✝ : Bicategory D
F✝ F : OplaxFunctor B C
G : OplaxFunctor C D
src✝ : PrelaxFunctor B D := PrelaxFunctor.comp F.toPrelaxFunctor G.toPrelaxFunctor
a : B
⊢ (↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map (𝟙 a) ⟶
    𝟙 ((↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).obj a)
[PROOFSTEP]
exact (G.mapFunctor _ _).map (F.mapId a) ≫ G.mapId (F.obj a)
[GOAL]
B : Type u₁
inst✝² : Bicategory B
C : Type u₂
inst✝¹ : Bicategory C
D : Type u₃
inst✝ : Bicategory D
F✝ F : OplaxFunctor B C
G : OplaxFunctor C D
src✝ : PrelaxFunctor B D := PrelaxFunctor.comp F.toPrelaxFunctor G.toPrelaxFunctor
a✝ b✝ c✝ : B
f : a✝ ⟶ b✝
g : b✝ ⟶ c✝
⊢ (↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map (f ≫ g) ⟶
    (↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map f ≫
      (↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map g
[PROOFSTEP]
exact (G.mapFunctor _ _).map (F.mapComp f g) ≫ G.mapComp (F.map f) (F.map g)
[GOAL]
B : Type u₁
inst✝² : Bicategory B
C : Type u₂
inst✝¹ : Bicategory C
D : Type u₃
inst✝ : Bicategory D
F✝ F : OplaxFunctor B C
G : OplaxFunctor C D
src✝ : PrelaxFunctor B D := PrelaxFunctor.comp F.toPrelaxFunctor G.toPrelaxFunctor
a✝ b✝ c✝ : B
f✝ f'✝ : a✝ ⟶ b✝
η : f✝ ⟶ f'✝
g : b✝ ⟶ c✝
⊢ PrelaxFunctor.map₂ { toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ } (η ▷ g) ≫
      (fun {a b c} f g =>
          (mapFunctor G ((↑F.toPrelaxFunctor).obj a) ((↑F.toPrelaxFunctor).obj c)).map (mapComp F f g) ≫
            mapComp G ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g))
        f'✝ g =
    (fun {a b c} f g =>
          (mapFunctor G ((↑F.toPrelaxFunctor).obj a) ((↑F.toPrelaxFunctor).obj c)).map (mapComp F f g) ≫
            mapComp G ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g))
        f✝ g ≫
      PrelaxFunctor.map₂ { toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ } η ▷
        (↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map g
[PROOFSTEP]
dsimp
[GOAL]
B : Type u₁
inst✝² : Bicategory B
C : Type u₂
inst✝¹ : Bicategory C
D : Type u₃
inst✝ : Bicategory D
F✝ F : OplaxFunctor B C
G : OplaxFunctor C D
src✝ : PrelaxFunctor B D := PrelaxFunctor.comp F.toPrelaxFunctor G.toPrelaxFunctor
a✝ b✝ c✝ : B
f✝ f'✝ : a✝ ⟶ b✝
η : f✝ ⟶ f'✝
g : b✝ ⟶ c✝
⊢ PrelaxFunctor.map₂ G.toPrelaxFunctor (PrelaxFunctor.map₂ F.toPrelaxFunctor (η ▷ g)) ≫
      PrelaxFunctor.map₂ G.toPrelaxFunctor (mapComp F f'✝ g) ≫
        mapComp G ((↑F.toPrelaxFunctor).map f'✝) ((↑F.toPrelaxFunctor).map g) =
    (PrelaxFunctor.map₂ G.toPrelaxFunctor (mapComp F f✝ g) ≫
        mapComp G ((↑F.toPrelaxFunctor).map f✝) ((↑F.toPrelaxFunctor).map g)) ≫
      PrelaxFunctor.map₂ G.toPrelaxFunctor (PrelaxFunctor.map₂ F.toPrelaxFunctor η) ▷
        (↑G.toPrelaxFunctor).map ((↑F.toPrelaxFunctor).map g)
[PROOFSTEP]
rw [← map₂_comp_assoc, mapComp_naturality_left, map₂_comp_assoc, mapComp_naturality_left, assoc]
[GOAL]
B : Type u₁
inst✝² : Bicategory B
C : Type u₂
inst✝¹ : Bicategory C
D : Type u₃
inst✝ : Bicategory D
F✝ F : OplaxFunctor B C
G : OplaxFunctor C D
src✝ : PrelaxFunctor B D := PrelaxFunctor.comp F.toPrelaxFunctor G.toPrelaxFunctor
a✝ b✝ c✝ : B
η : a✝ ⟶ b✝
⊢ ∀ {g g' : b✝ ⟶ c✝} (η_1 : g ⟶ g'),
    PrelaxFunctor.map₂ { toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ } (η ◁ η_1) ≫
        (fun {a b c} f g =>
            (mapFunctor G ((↑F.toPrelaxFunctor).obj a) ((↑F.toPrelaxFunctor).obj c)).map (mapComp F f g) ≫
              mapComp G ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g))
          η g' =
      (fun {a b c} f g =>
            (mapFunctor G ((↑F.toPrelaxFunctor).obj a) ((↑F.toPrelaxFunctor).obj c)).map (mapComp F f g) ≫
              mapComp G ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g))
          η g ≫
        (↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map η ◁
          PrelaxFunctor.map₂ { toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ } η_1
[PROOFSTEP]
dsimp
[GOAL]
B : Type u₁
inst✝² : Bicategory B
C : Type u₂
inst✝¹ : Bicategory C
D : Type u₃
inst✝ : Bicategory D
F✝ F : OplaxFunctor B C
G : OplaxFunctor C D
src✝ : PrelaxFunctor B D := PrelaxFunctor.comp F.toPrelaxFunctor G.toPrelaxFunctor
a✝ b✝ c✝ : B
η : a✝ ⟶ b✝
⊢ ∀ {g g' : b✝ ⟶ c✝} (η_1 : g ⟶ g'),
    PrelaxFunctor.map₂ G.toPrelaxFunctor (PrelaxFunctor.map₂ F.toPrelaxFunctor (η ◁ η_1)) ≫
        PrelaxFunctor.map₂ G.toPrelaxFunctor (mapComp F η g') ≫
          mapComp G ((↑F.toPrelaxFunctor).map η) ((↑F.toPrelaxFunctor).map g') =
      (PrelaxFunctor.map₂ G.toPrelaxFunctor (mapComp F η g) ≫
          mapComp G ((↑F.toPrelaxFunctor).map η) ((↑F.toPrelaxFunctor).map g)) ≫
        (↑G.toPrelaxFunctor).map ((↑F.toPrelaxFunctor).map η) ◁
          PrelaxFunctor.map₂ G.toPrelaxFunctor (PrelaxFunctor.map₂ F.toPrelaxFunctor η_1)
[PROOFSTEP]
intros
[GOAL]
B : Type u₁
inst✝² : Bicategory B
C : Type u₂
inst✝¹ : Bicategory C
D : Type u₃
inst✝ : Bicategory D
F✝ F : OplaxFunctor B C
G : OplaxFunctor C D
src✝ : PrelaxFunctor B D := PrelaxFunctor.comp F.toPrelaxFunctor G.toPrelaxFunctor
a✝ b✝ c✝ : B
η : a✝ ⟶ b✝
g✝ g'✝ : b✝ ⟶ c✝
η✝ : g✝ ⟶ g'✝
⊢ PrelaxFunctor.map₂ G.toPrelaxFunctor (PrelaxFunctor.map₂ F.toPrelaxFunctor (η ◁ η✝)) ≫
      PrelaxFunctor.map₂ G.toPrelaxFunctor (mapComp F η g'✝) ≫
        mapComp G ((↑F.toPrelaxFunctor).map η) ((↑F.toPrelaxFunctor).map g'✝) =
    (PrelaxFunctor.map₂ G.toPrelaxFunctor (mapComp F η g✝) ≫
        mapComp G ((↑F.toPrelaxFunctor).map η) ((↑F.toPrelaxFunctor).map g✝)) ≫
      (↑G.toPrelaxFunctor).map ((↑F.toPrelaxFunctor).map η) ◁
        PrelaxFunctor.map₂ G.toPrelaxFunctor (PrelaxFunctor.map₂ F.toPrelaxFunctor η✝)
[PROOFSTEP]
rw [← map₂_comp_assoc, mapComp_naturality_right, map₂_comp_assoc, mapComp_naturality_right, assoc]
[GOAL]
B : Type u₁
inst✝² : Bicategory B
C : Type u₂
inst✝¹ : Bicategory C
D : Type u₃
inst✝ : Bicategory D
F✝ F : OplaxFunctor B C
G : OplaxFunctor C D
src✝ : PrelaxFunctor B D := PrelaxFunctor.comp F.toPrelaxFunctor G.toPrelaxFunctor
a✝ b✝ c✝ d✝ : B
f : a✝ ⟶ b✝
g : b✝ ⟶ c✝
h : c✝ ⟶ d✝
⊢ PrelaxFunctor.map₂ { toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ } (α_ f g h).hom ≫
      (fun {a b c} f g =>
            (mapFunctor G ((↑F.toPrelaxFunctor).obj a) ((↑F.toPrelaxFunctor).obj c)).map (mapComp F f g) ≫
              mapComp G ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g))
          f (g ≫ h) ≫
        (↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map f ◁
          (fun {a b c} f g =>
              (mapFunctor G ((↑F.toPrelaxFunctor).obj a) ((↑F.toPrelaxFunctor).obj c)).map (mapComp F f g) ≫
                mapComp G ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g))
            g h =
    (fun {a b c} f g =>
          (mapFunctor G ((↑F.toPrelaxFunctor).obj a) ((↑F.toPrelaxFunctor).obj c)).map (mapComp F f g) ≫
            mapComp G ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g))
        (f ≫ g) h ≫
      (fun {a b c} f g =>
              (mapFunctor G ((↑F.toPrelaxFunctor).obj a) ((↑F.toPrelaxFunctor).obj c)).map (mapComp F f g) ≫
                mapComp G ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g))
            f g ▷
          (↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map h ≫
        (α_ ((↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map f)
            ((↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map g)
            ((↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map h)).hom
[PROOFSTEP]
dsimp
  -- porting note: if you use the `map₂_associator_aux` hack in the definition of
        -- `map₂_associator` then the `simp only` call below does not seem to apply `map₂_associator`
[GOAL]
B : Type u₁
inst✝² : Bicategory B
C : Type u₂
inst✝¹ : Bicategory C
D : Type u₃
inst✝ : Bicategory D
F✝ F : OplaxFunctor B C
G : OplaxFunctor C D
src✝ : PrelaxFunctor B D := PrelaxFunctor.comp F.toPrelaxFunctor G.toPrelaxFunctor
a✝ b✝ c✝ d✝ : B
f : a✝ ⟶ b✝
g : b✝ ⟶ c✝
h : c✝ ⟶ d✝
⊢ PrelaxFunctor.map₂ G.toPrelaxFunctor (PrelaxFunctor.map₂ F.toPrelaxFunctor (α_ f g h).hom) ≫
      (PrelaxFunctor.map₂ G.toPrelaxFunctor (mapComp F f (g ≫ h)) ≫
          mapComp G ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map (g ≫ h))) ≫
        (↑G.toPrelaxFunctor).map ((↑F.toPrelaxFunctor).map f) ◁
          (PrelaxFunctor.map₂ G.toPrelaxFunctor (mapComp F g h) ≫
            mapComp G ((↑F.toPrelaxFunctor).map g) ((↑F.toPrelaxFunctor).map h)) =
    (PrelaxFunctor.map₂ G.toPrelaxFunctor (mapComp F (f ≫ g) h) ≫
        mapComp G ((↑F.toPrelaxFunctor).map (f ≫ g)) ((↑F.toPrelaxFunctor).map h)) ≫
      (PrelaxFunctor.map₂ G.toPrelaxFunctor (mapComp F f g) ≫
            mapComp G ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g)) ▷
          (↑G.toPrelaxFunctor).map ((↑F.toPrelaxFunctor).map h) ≫
        (α_ ((↑G.toPrelaxFunctor).map ((↑F.toPrelaxFunctor).map f))
            ((↑G.toPrelaxFunctor).map ((↑F.toPrelaxFunctor).map g))
            ((↑G.toPrelaxFunctor).map ((↑F.toPrelaxFunctor).map h))).hom
[PROOFSTEP]
simp only [map₂_associator, ← map₂_comp_assoc, ← mapComp_naturality_right_assoc, whiskerLeft_comp, assoc]
[GOAL]
B : Type u₁
inst✝² : Bicategory B
C : Type u₂
inst✝¹ : Bicategory C
D : Type u₃
inst✝ : Bicategory D
F✝ F : OplaxFunctor B C
G : OplaxFunctor C D
src✝ : PrelaxFunctor B D := PrelaxFunctor.comp F.toPrelaxFunctor G.toPrelaxFunctor
a✝ b✝ c✝ d✝ : B
f : a✝ ⟶ b✝
g : b✝ ⟶ c✝
h : c✝ ⟶ d✝
⊢ PrelaxFunctor.map₂ G.toPrelaxFunctor
        (mapComp F (f ≫ g) h ≫
          mapComp F f g ▷ (↑F.toPrelaxFunctor).map h ≫
            (α_ ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g) ((↑F.toPrelaxFunctor).map h)).hom) ≫
      mapComp G ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g ≫ (↑F.toPrelaxFunctor).map h) ≫
        (↑G.toPrelaxFunctor).map ((↑F.toPrelaxFunctor).map f) ◁
          mapComp G ((↑F.toPrelaxFunctor).map g) ((↑F.toPrelaxFunctor).map h) =
    PrelaxFunctor.map₂ G.toPrelaxFunctor (mapComp F (f ≫ g) h) ≫
      mapComp G ((↑F.toPrelaxFunctor).map (f ≫ g)) ((↑F.toPrelaxFunctor).map h) ≫
        (PrelaxFunctor.map₂ G.toPrelaxFunctor (mapComp F f g) ≫
              mapComp G ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g)) ▷
            (↑G.toPrelaxFunctor).map ((↑F.toPrelaxFunctor).map h) ≫
          (α_ ((↑G.toPrelaxFunctor).map ((↑F.toPrelaxFunctor).map f))
              ((↑G.toPrelaxFunctor).map ((↑F.toPrelaxFunctor).map g))
              ((↑G.toPrelaxFunctor).map ((↑F.toPrelaxFunctor).map h))).hom
[PROOFSTEP]
simp only [map₂_associator, map₂_comp, mapComp_naturality_left_assoc, comp_whiskerRight, assoc]
[GOAL]
B : Type u₁
inst✝² : Bicategory B
C : Type u₂
inst✝¹ : Bicategory C
D : Type u₃
inst✝ : Bicategory D
F✝ F : OplaxFunctor B C
G : OplaxFunctor C D
src✝ : PrelaxFunctor B D := PrelaxFunctor.comp F.toPrelaxFunctor G.toPrelaxFunctor
a✝ b✝ : B
f : a✝ ⟶ b✝
⊢ PrelaxFunctor.map₂ { toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ } (λ_ f).hom =
    (fun {a b c} f g =>
          (mapFunctor G ((↑F.toPrelaxFunctor).obj a) ((↑F.toPrelaxFunctor).obj c)).map (mapComp F f g) ≫
            mapComp G ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g))
        (𝟙 a✝) f ≫
      (fun a =>
              (mapFunctor G ((↑F.toPrelaxFunctor).obj a) ((↑F.toPrelaxFunctor).obj a)).map (mapId F a) ≫
                mapId G ((↑F.toPrelaxFunctor).obj a))
            a✝ ▷
          (↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map f ≫
        (λ_ ((↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map f)).hom
[PROOFSTEP]
dsimp
[GOAL]
B : Type u₁
inst✝² : Bicategory B
C : Type u₂
inst✝¹ : Bicategory C
D : Type u₃
inst✝ : Bicategory D
F✝ F : OplaxFunctor B C
G : OplaxFunctor C D
src✝ : PrelaxFunctor B D := PrelaxFunctor.comp F.toPrelaxFunctor G.toPrelaxFunctor
a✝ b✝ : B
f : a✝ ⟶ b✝
⊢ PrelaxFunctor.map₂ G.toPrelaxFunctor (PrelaxFunctor.map₂ F.toPrelaxFunctor (λ_ f).hom) =
    (PrelaxFunctor.map₂ G.toPrelaxFunctor (mapComp F (𝟙 a✝) f) ≫
        mapComp G ((↑F.toPrelaxFunctor).map (𝟙 a✝)) ((↑F.toPrelaxFunctor).map f)) ≫
      (PrelaxFunctor.map₂ G.toPrelaxFunctor (mapId F a✝) ≫ mapId G ((↑F.toPrelaxFunctor).obj a✝)) ▷
          (↑G.toPrelaxFunctor).map ((↑F.toPrelaxFunctor).map f) ≫
        (λ_ ((↑G.toPrelaxFunctor).map ((↑F.toPrelaxFunctor).map f))).hom
[PROOFSTEP]
simp only [map₂_leftUnitor, map₂_comp, mapComp_naturality_left_assoc, comp_whiskerRight, assoc]
[GOAL]
B : Type u₁
inst✝² : Bicategory B
C : Type u₂
inst✝¹ : Bicategory C
D : Type u₃
inst✝ : Bicategory D
F✝ F : OplaxFunctor B C
G : OplaxFunctor C D
src✝ : PrelaxFunctor B D := PrelaxFunctor.comp F.toPrelaxFunctor G.toPrelaxFunctor
a✝ b✝ : B
f : a✝ ⟶ b✝
⊢ PrelaxFunctor.map₂ { toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ } (ρ_ f).hom =
    (fun {a b c} f g =>
          (mapFunctor G ((↑F.toPrelaxFunctor).obj a) ((↑F.toPrelaxFunctor).obj c)).map (mapComp F f g) ≫
            mapComp G ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g))
        f (𝟙 b✝) ≫
      (↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map f ◁
          (fun a =>
              (mapFunctor G ((↑F.toPrelaxFunctor).obj a) ((↑F.toPrelaxFunctor).obj a)).map (mapId F a) ≫
                mapId G ((↑F.toPrelaxFunctor).obj a))
            b✝ ≫
        (ρ_ ((↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map f)).hom
[PROOFSTEP]
dsimp
[GOAL]
B : Type u₁
inst✝² : Bicategory B
C : Type u₂
inst✝¹ : Bicategory C
D : Type u₃
inst✝ : Bicategory D
F✝ F : OplaxFunctor B C
G : OplaxFunctor C D
src✝ : PrelaxFunctor B D := PrelaxFunctor.comp F.toPrelaxFunctor G.toPrelaxFunctor
a✝ b✝ : B
f : a✝ ⟶ b✝
⊢ PrelaxFunctor.map₂ G.toPrelaxFunctor (PrelaxFunctor.map₂ F.toPrelaxFunctor (ρ_ f).hom) =
    (PrelaxFunctor.map₂ G.toPrelaxFunctor (mapComp F f (𝟙 b✝)) ≫
        mapComp G ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map (𝟙 b✝))) ≫
      (↑G.toPrelaxFunctor).map ((↑F.toPrelaxFunctor).map f) ◁
          (PrelaxFunctor.map₂ G.toPrelaxFunctor (mapId F b✝) ≫ mapId G ((↑F.toPrelaxFunctor).obj b✝)) ≫
        (ρ_ ((↑G.toPrelaxFunctor).map ((↑F.toPrelaxFunctor).map f))).hom
[PROOFSTEP]
simp only [map₂_rightUnitor, map₂_comp, mapComp_naturality_right_assoc, whiskerLeft_comp, assoc]
[GOAL]
B : Type u₁
inst✝² : Bicategory B
C : Type u₂
inst✝¹ : Bicategory C
D : Type u₃
inst✝ : Bicategory D
F✝ : Pseudofunctor B C
F : OplaxFunctor B C
F' : OplaxFunctor.PseudoCore F
src✝ : PrelaxFunctor B C := F.toPrelaxFunctor
a✝ b✝ c✝ : B
f : a✝ ⟶ b✝
g h : b✝ ⟶ c✝
η : g ⟶ h
⊢ PrelaxFunctor.map₂ { toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ } (f ◁ η) =
    ((fun {a b c} => OplaxFunctor.PseudoCore.mapCompIso F') f g).hom ≫
      (↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map f ◁
          PrelaxFunctor.map₂ { toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ } η ≫
        ((fun {a b c} => OplaxFunctor.PseudoCore.mapCompIso F') f h).inv
[PROOFSTEP]
dsimp
[GOAL]
B : Type u₁
inst✝² : Bicategory B
C : Type u₂
inst✝¹ : Bicategory C
D : Type u₃
inst✝ : Bicategory D
F✝ : Pseudofunctor B C
F : OplaxFunctor B C
F' : OplaxFunctor.PseudoCore F
src✝ : PrelaxFunctor B C := F.toPrelaxFunctor
a✝ b✝ c✝ : B
f : a✝ ⟶ b✝
g h : b✝ ⟶ c✝
η : g ⟶ h
⊢ PrelaxFunctor.map₂ F.toPrelaxFunctor (f ◁ η) =
    (OplaxFunctor.PseudoCore.mapCompIso F' f g).hom ≫
      (↑F.toPrelaxFunctor).map f ◁ PrelaxFunctor.map₂ F.toPrelaxFunctor η ≫
        (OplaxFunctor.PseudoCore.mapCompIso F' f h).inv
[PROOFSTEP]
rw [F'.mapCompIso_hom f g, ← F.mapComp_naturality_right_assoc, ← F'.mapCompIso_hom f h, hom_inv_id, comp_id]
[GOAL]
B : Type u₁
inst✝² : Bicategory B
C : Type u₂
inst✝¹ : Bicategory C
D : Type u₃
inst✝ : Bicategory D
F✝ : Pseudofunctor B C
F : OplaxFunctor B C
F' : OplaxFunctor.PseudoCore F
src✝ : PrelaxFunctor B C := F.toPrelaxFunctor
a✝ b✝ c✝ : B
f✝ g✝ : a✝ ⟶ b✝
η : f✝ ⟶ g✝
h : b✝ ⟶ c✝
⊢ PrelaxFunctor.map₂ { toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ } (η ▷ h) =
    ((fun {a b c} => OplaxFunctor.PseudoCore.mapCompIso F') f✝ h).hom ≫
      PrelaxFunctor.map₂ { toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ } η ▷
          (↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map h ≫
        ((fun {a b c} => OplaxFunctor.PseudoCore.mapCompIso F') g✝ h).inv
[PROOFSTEP]
dsimp
[GOAL]
B : Type u₁
inst✝² : Bicategory B
C : Type u₂
inst✝¹ : Bicategory C
D : Type u₃
inst✝ : Bicategory D
F✝ : Pseudofunctor B C
F : OplaxFunctor B C
F' : OplaxFunctor.PseudoCore F
src✝ : PrelaxFunctor B C := F.toPrelaxFunctor
a✝ b✝ c✝ : B
f✝ g✝ : a✝ ⟶ b✝
η : f✝ ⟶ g✝
h : b✝ ⟶ c✝
⊢ PrelaxFunctor.map₂ F.toPrelaxFunctor (η ▷ h) =
    (OplaxFunctor.PseudoCore.mapCompIso F' f✝ h).hom ≫
      PrelaxFunctor.map₂ F.toPrelaxFunctor η ▷ (↑F.toPrelaxFunctor).map h ≫
        (OplaxFunctor.PseudoCore.mapCompIso F' g✝ h).inv
[PROOFSTEP]
rw [F'.mapCompIso_hom _ h, ← F.mapComp_naturality_left_assoc, ← F'.mapCompIso_hom _ h, hom_inv_id, comp_id]
[GOAL]
B : Type u₁
inst✝² : Bicategory B
C : Type u₂
inst✝¹ : Bicategory C
D : Type u₃
inst✝ : Bicategory D
F✝ : Pseudofunctor B C
F : OplaxFunctor B C
F' : OplaxFunctor.PseudoCore F
src✝ : PrelaxFunctor B C := F.toPrelaxFunctor
a✝ b✝ c✝ d✝ : B
f : a✝ ⟶ b✝
g : b✝ ⟶ c✝
h : c✝ ⟶ d✝
⊢ PrelaxFunctor.map₂ { toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ } (α_ f g h).hom =
    ((fun {a b c} => OplaxFunctor.PseudoCore.mapCompIso F') (f ≫ g) h).hom ≫
      ((fun {a b c} => OplaxFunctor.PseudoCore.mapCompIso F') f g).hom ▷
          (↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map h ≫
        (α_ ((↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map f)
              ((↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map g)
              ((↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map h)).hom ≫
          (↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map f ◁
              ((fun {a b c} => OplaxFunctor.PseudoCore.mapCompIso F') g h).inv ≫
            ((fun {a b c} => OplaxFunctor.PseudoCore.mapCompIso F') f (g ≫ h)).inv
[PROOFSTEP]
dsimp
[GOAL]
B : Type u₁
inst✝² : Bicategory B
C : Type u₂
inst✝¹ : Bicategory C
D : Type u₃
inst✝ : Bicategory D
F✝ : Pseudofunctor B C
F : OplaxFunctor B C
F' : OplaxFunctor.PseudoCore F
src✝ : PrelaxFunctor B C := F.toPrelaxFunctor
a✝ b✝ c✝ d✝ : B
f : a✝ ⟶ b✝
g : b✝ ⟶ c✝
h : c✝ ⟶ d✝
⊢ PrelaxFunctor.map₂ F.toPrelaxFunctor (α_ f g h).hom =
    (OplaxFunctor.PseudoCore.mapCompIso F' (f ≫ g) h).hom ≫
      (OplaxFunctor.PseudoCore.mapCompIso F' f g).hom ▷ (↑F.toPrelaxFunctor).map h ≫
        (α_ ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g) ((↑F.toPrelaxFunctor).map h)).hom ≫
          (↑F.toPrelaxFunctor).map f ◁ (OplaxFunctor.PseudoCore.mapCompIso F' g h).inv ≫
            (OplaxFunctor.PseudoCore.mapCompIso F' f (g ≫ h)).inv
[PROOFSTEP]
rw [F'.mapCompIso_hom (f ≫ g) h, F'.mapCompIso_hom f g, ← F.map₂_associator_assoc, ← F'.mapCompIso_hom f (g ≫ h), ←
  F'.mapCompIso_hom g h, hom_inv_whiskerLeft_assoc, hom_inv_id, comp_id]
[GOAL]
B : Type u₁
inst✝⁴ : Bicategory B
C : Type u₂
inst✝³ : Bicategory C
D : Type u₃
inst✝² : Bicategory D
F✝ : Pseudofunctor B C
F : OplaxFunctor B C
inst✝¹ : ∀ (a : B), IsIso (OplaxFunctor.mapId F a)
inst✝ : ∀ {a b c : B} (f : a ⟶ b) (g : b ⟶ c), IsIso (OplaxFunctor.mapComp F f g)
src✝ : PrelaxFunctor B C := F.toPrelaxFunctor
a✝ b✝ c✝ : B
f : a✝ ⟶ b✝
g h : b✝ ⟶ c✝
η : g ⟶ h
⊢ PrelaxFunctor.map₂ { toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ } (f ◁ η) =
    ((fun {a b c} f g => asIso (OplaxFunctor.mapComp F f g)) f g).hom ≫
      (↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map f ◁
          PrelaxFunctor.map₂ { toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ } η ≫
        ((fun {a b c} f g => asIso (OplaxFunctor.mapComp F f g)) f h).inv
[PROOFSTEP]
dsimp
[GOAL]
B : Type u₁
inst✝⁴ : Bicategory B
C : Type u₂
inst✝³ : Bicategory C
D : Type u₃
inst✝² : Bicategory D
F✝ : Pseudofunctor B C
F : OplaxFunctor B C
inst✝¹ : ∀ (a : B), IsIso (OplaxFunctor.mapId F a)
inst✝ : ∀ {a b c : B} (f : a ⟶ b) (g : b ⟶ c), IsIso (OplaxFunctor.mapComp F f g)
src✝ : PrelaxFunctor B C := F.toPrelaxFunctor
a✝ b✝ c✝ : B
f : a✝ ⟶ b✝
g h : b✝ ⟶ c✝
η : g ⟶ h
⊢ PrelaxFunctor.map₂ F.toPrelaxFunctor (f ◁ η) =
    OplaxFunctor.mapComp F f g ≫
      (↑F.toPrelaxFunctor).map f ◁ PrelaxFunctor.map₂ F.toPrelaxFunctor η ≫ inv (OplaxFunctor.mapComp F f h)
[PROOFSTEP]
rw [← assoc, IsIso.eq_comp_inv, F.mapComp_naturality_right]
[GOAL]
B : Type u₁
inst✝⁴ : Bicategory B
C : Type u₂
inst✝³ : Bicategory C
D : Type u₃
inst✝² : Bicategory D
F✝ : Pseudofunctor B C
F : OplaxFunctor B C
inst✝¹ : ∀ (a : B), IsIso (OplaxFunctor.mapId F a)
inst✝ : ∀ {a b c : B} (f : a ⟶ b) (g : b ⟶ c), IsIso (OplaxFunctor.mapComp F f g)
src✝ : PrelaxFunctor B C := F.toPrelaxFunctor
a✝ b✝ c✝ : B
f✝ g✝ : a✝ ⟶ b✝
η : f✝ ⟶ g✝
h : b✝ ⟶ c✝
⊢ PrelaxFunctor.map₂ { toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ } (η ▷ h) =
    ((fun {a b c} f g => asIso (OplaxFunctor.mapComp F f g)) f✝ h).hom ≫
      PrelaxFunctor.map₂ { toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ } η ▷
          (↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map h ≫
        ((fun {a b c} f g => asIso (OplaxFunctor.mapComp F f g)) g✝ h).inv
[PROOFSTEP]
dsimp
[GOAL]
B : Type u₁
inst✝⁴ : Bicategory B
C : Type u₂
inst✝³ : Bicategory C
D : Type u₃
inst✝² : Bicategory D
F✝ : Pseudofunctor B C
F : OplaxFunctor B C
inst✝¹ : ∀ (a : B), IsIso (OplaxFunctor.mapId F a)
inst✝ : ∀ {a b c : B} (f : a ⟶ b) (g : b ⟶ c), IsIso (OplaxFunctor.mapComp F f g)
src✝ : PrelaxFunctor B C := F.toPrelaxFunctor
a✝ b✝ c✝ : B
f✝ g✝ : a✝ ⟶ b✝
η : f✝ ⟶ g✝
h : b✝ ⟶ c✝
⊢ PrelaxFunctor.map₂ F.toPrelaxFunctor (η ▷ h) =
    OplaxFunctor.mapComp F f✝ h ≫
      PrelaxFunctor.map₂ F.toPrelaxFunctor η ▷ (↑F.toPrelaxFunctor).map h ≫ inv (OplaxFunctor.mapComp F g✝ h)
[PROOFSTEP]
rw [← assoc, IsIso.eq_comp_inv, F.mapComp_naturality_left]
[GOAL]
B : Type u₁
inst✝⁴ : Bicategory B
C : Type u₂
inst✝³ : Bicategory C
D : Type u₃
inst✝² : Bicategory D
F✝ : Pseudofunctor B C
F : OplaxFunctor B C
inst✝¹ : ∀ (a : B), IsIso (OplaxFunctor.mapId F a)
inst✝ : ∀ {a b c : B} (f : a ⟶ b) (g : b ⟶ c), IsIso (OplaxFunctor.mapComp F f g)
src✝ : PrelaxFunctor B C := F.toPrelaxFunctor
a✝ b✝ c✝ d✝ : B
f : a✝ ⟶ b✝
g : b✝ ⟶ c✝
h : c✝ ⟶ d✝
⊢ PrelaxFunctor.map₂ { toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ } (α_ f g h).hom =
    ((fun {a b c} f g => asIso (OplaxFunctor.mapComp F f g)) (f ≫ g) h).hom ≫
      ((fun {a b c} f g => asIso (OplaxFunctor.mapComp F f g)) f g).hom ▷
          (↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map h ≫
        (α_ ((↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map f)
              ((↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map g)
              ((↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map h)).hom ≫
          (↑{ toPrefunctor := ↑src✝, map₂ := fun {a b} {f g} => PrelaxFunctor.map₂ src✝ }).map f ◁
              ((fun {a b c} f g => asIso (OplaxFunctor.mapComp F f g)) g h).inv ≫
            ((fun {a b c} f g => asIso (OplaxFunctor.mapComp F f g)) f (g ≫ h)).inv
[PROOFSTEP]
dsimp
[GOAL]
B : Type u₁
inst✝⁴ : Bicategory B
C : Type u₂
inst✝³ : Bicategory C
D : Type u₃
inst✝² : Bicategory D
F✝ : Pseudofunctor B C
F : OplaxFunctor B C
inst✝¹ : ∀ (a : B), IsIso (OplaxFunctor.mapId F a)
inst✝ : ∀ {a b c : B} (f : a ⟶ b) (g : b ⟶ c), IsIso (OplaxFunctor.mapComp F f g)
src✝ : PrelaxFunctor B C := F.toPrelaxFunctor
a✝ b✝ c✝ d✝ : B
f : a✝ ⟶ b✝
g : b✝ ⟶ c✝
h : c✝ ⟶ d✝
⊢ PrelaxFunctor.map₂ F.toPrelaxFunctor (α_ f g h).hom =
    OplaxFunctor.mapComp F (f ≫ g) h ≫
      OplaxFunctor.mapComp F f g ▷ (↑F.toPrelaxFunctor).map h ≫
        (α_ ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g) ((↑F.toPrelaxFunctor).map h)).hom ≫
          (↑F.toPrelaxFunctor).map f ◁ inv (OplaxFunctor.mapComp F g h) ≫ inv (OplaxFunctor.mapComp F f (g ≫ h))
[PROOFSTEP]
simp only [← assoc]
[GOAL]
B : Type u₁
inst✝⁴ : Bicategory B
C : Type u₂
inst✝³ : Bicategory C
D : Type u₃
inst✝² : Bicategory D
F✝ : Pseudofunctor B C
F : OplaxFunctor B C
inst✝¹ : ∀ (a : B), IsIso (OplaxFunctor.mapId F a)
inst✝ : ∀ {a b c : B} (f : a ⟶ b) (g : b ⟶ c), IsIso (OplaxFunctor.mapComp F f g)
src✝ : PrelaxFunctor B C := F.toPrelaxFunctor
a✝ b✝ c✝ d✝ : B
f : a✝ ⟶ b✝
g : b✝ ⟶ c✝
h : c✝ ⟶ d✝
⊢ PrelaxFunctor.map₂ F.toPrelaxFunctor (α_ f g h).hom =
    (((OplaxFunctor.mapComp F (f ≫ g) h ≫ OplaxFunctor.mapComp F f g ▷ (↑F.toPrelaxFunctor).map h) ≫
          (α_ ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g) ((↑F.toPrelaxFunctor).map h)).hom) ≫
        (↑F.toPrelaxFunctor).map f ◁ inv (OplaxFunctor.mapComp F g h)) ≫
      inv (OplaxFunctor.mapComp F f (g ≫ h))
[PROOFSTEP]
rw [IsIso.eq_comp_inv, ← inv_whiskerLeft, IsIso.eq_comp_inv]
[GOAL]
B : Type u₁
inst✝⁴ : Bicategory B
C : Type u₂
inst✝³ : Bicategory C
D : Type u₃
inst✝² : Bicategory D
F✝ : Pseudofunctor B C
F : OplaxFunctor B C
inst✝¹ : ∀ (a : B), IsIso (OplaxFunctor.mapId F a)
inst✝ : ∀ {a b c : B} (f : a ⟶ b) (g : b ⟶ c), IsIso (OplaxFunctor.mapComp F f g)
src✝ : PrelaxFunctor B C := F.toPrelaxFunctor
a✝ b✝ c✝ d✝ : B
f : a✝ ⟶ b✝
g : b✝ ⟶ c✝
h : c✝ ⟶ d✝
⊢ (PrelaxFunctor.map₂ F.toPrelaxFunctor (α_ f g h).hom ≫ OplaxFunctor.mapComp F f (g ≫ h)) ≫
      (↑F.toPrelaxFunctor).map f ◁ OplaxFunctor.mapComp F g h =
    (OplaxFunctor.mapComp F (f ≫ g) h ≫ OplaxFunctor.mapComp F f g ▷ (↑F.toPrelaxFunctor).map h) ≫
      (α_ ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g) ((↑F.toPrelaxFunctor).map h)).hom
[PROOFSTEP]
simp only [assoc, F.map₂_associator]


[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
f g : CentroidHom α
h : (fun f => f.toFun) f = (fun f => f.toFun) g
⊢ f = g
[PROOFSTEP]
cases f
[GOAL]
case mk
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
g : CentroidHom α
toAddMonoidHom✝ : α →+ α
map_mul_left'✝ : ∀ (a b : α), ZeroHom.toFun (↑toAddMonoidHom✝) (a * b) = a * ZeroHom.toFun (↑toAddMonoidHom✝) b
map_mul_right'✝ : ∀ (a b : α), ZeroHom.toFun (↑toAddMonoidHom✝) (a * b) = ZeroHom.toFun (↑toAddMonoidHom✝) a * b
h :
  (fun f => f.toFun)
      { toAddMonoidHom := toAddMonoidHom✝, map_mul_left' := map_mul_left'✝, map_mul_right' := map_mul_right'✝ } =
    (fun f => f.toFun) g
⊢ { toAddMonoidHom := toAddMonoidHom✝, map_mul_left' := map_mul_left'✝, map_mul_right' := map_mul_right'✝ } = g
[PROOFSTEP]
cases g
[GOAL]
case mk.mk
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
toAddMonoidHom✝¹ : α →+ α
map_mul_left'✝¹ : ∀ (a b : α), ZeroHom.toFun (↑toAddMonoidHom✝¹) (a * b) = a * ZeroHom.toFun (↑toAddMonoidHom✝¹) b
map_mul_right'✝¹ : ∀ (a b : α), ZeroHom.toFun (↑toAddMonoidHom✝¹) (a * b) = ZeroHom.toFun (↑toAddMonoidHom✝¹) a * b
toAddMonoidHom✝ : α →+ α
map_mul_left'✝ : ∀ (a b : α), ZeroHom.toFun (↑toAddMonoidHom✝) (a * b) = a * ZeroHom.toFun (↑toAddMonoidHom✝) b
map_mul_right'✝ : ∀ (a b : α), ZeroHom.toFun (↑toAddMonoidHom✝) (a * b) = ZeroHom.toFun (↑toAddMonoidHom✝) a * b
h :
  (fun f => f.toFun)
      { toAddMonoidHom := toAddMonoidHom✝¹, map_mul_left' := map_mul_left'✝¹, map_mul_right' := map_mul_right'✝¹ } =
    (fun f => f.toFun)
      { toAddMonoidHom := toAddMonoidHom✝, map_mul_left' := map_mul_left'✝, map_mul_right' := map_mul_right'✝ }
⊢ { toAddMonoidHom := toAddMonoidHom✝¹, map_mul_left' := map_mul_left'✝¹, map_mul_right' := map_mul_right'✝¹ } =
    { toAddMonoidHom := toAddMonoidHom✝, map_mul_left' := map_mul_left'✝, map_mul_right' := map_mul_right'✝ }
[PROOFSTEP]
congr with x
[GOAL]
case mk.mk.e_toAddMonoidHom.h
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
toAddMonoidHom✝¹ : α →+ α
map_mul_left'✝¹ : ∀ (a b : α), ZeroHom.toFun (↑toAddMonoidHom✝¹) (a * b) = a * ZeroHom.toFun (↑toAddMonoidHom✝¹) b
map_mul_right'✝¹ : ∀ (a b : α), ZeroHom.toFun (↑toAddMonoidHom✝¹) (a * b) = ZeroHom.toFun (↑toAddMonoidHom✝¹) a * b
toAddMonoidHom✝ : α →+ α
map_mul_left'✝ : ∀ (a b : α), ZeroHom.toFun (↑toAddMonoidHom✝) (a * b) = a * ZeroHom.toFun (↑toAddMonoidHom✝) b
map_mul_right'✝ : ∀ (a b : α), ZeroHom.toFun (↑toAddMonoidHom✝) (a * b) = ZeroHom.toFun (↑toAddMonoidHom✝) a * b
h :
  (fun f => f.toFun)
      { toAddMonoidHom := toAddMonoidHom✝¹, map_mul_left' := map_mul_left'✝¹, map_mul_right' := map_mul_right'✝¹ } =
    (fun f => f.toFun)
      { toAddMonoidHom := toAddMonoidHom✝, map_mul_left' := map_mul_left'✝, map_mul_right' := map_mul_right'✝ }
x : α
⊢ ↑toAddMonoidHom✝¹ x = ↑toAddMonoidHom✝ x
[PROOFSTEP]
exact congrFun h x
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
f : CentroidHom α
f' : α → α
h : f' = ↑f
src✝ : α →+ α := AddMonoidHom.copy f.toAddMonoidHom f' h
a b : α
⊢ ZeroHom.toFun
      (↑{ toZeroHom := { toFun := f', map_zero' := (_ : ZeroHom.toFun (↑src✝) 0 = 0) },
          map_add' :=
            (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
      (a * b) =
    a *
      ZeroHom.toFun
        (↑{ toZeroHom := { toFun := f', map_zero' := (_ : ZeroHom.toFun (↑src✝) 0 = 0) },
            map_add' :=
              (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
        b
[PROOFSTEP]
simp_rw [h, map_mul_left]
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
f : CentroidHom α
f' : α → α
h : f' = ↑f
src✝ : α →+ α := AddMonoidHom.copy f.toAddMonoidHom f' h
a b : α
⊢ ZeroHom.toFun
      (↑{ toZeroHom := { toFun := f', map_zero' := (_ : ZeroHom.toFun (↑src✝) 0 = 0) },
          map_add' :=
            (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
      (a * b) =
    ZeroHom.toFun
        (↑{ toZeroHom := { toFun := f', map_zero' := (_ : ZeroHom.toFun (↑src✝) 0 = 0) },
            map_add' :=
              (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
        a *
      b
[PROOFSTEP]
simp_rw [h, map_mul_right]
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
g f₁ f₂ : CentroidHom α
hg : Injective ↑g
h : comp g f₁ = comp g f₂
a : α
⊢ ↑g (↑f₁ a) = ↑g (↑f₂ a)
[PROOFSTEP]
rw [← comp_apply, h, comp_apply]
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
f g : CentroidHom α
src✝ : α →+ α := ↑f + ↑g
a b : α
⊢ ZeroHom.toFun
      (↑{ toZeroHom := ↑src✝,
          map_add' :=
            (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
      (a * b) =
    a *
      ZeroHom.toFun
        (↑{ toZeroHom := ↑src✝,
            map_add' :=
              (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
        b
[PROOFSTEP]
show f (a * b) + g (a * b) = a * (f b + g b)
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
f g : CentroidHom α
src✝ : α →+ α := ↑f + ↑g
a b : α
⊢ ↑f (a * b) + ↑g (a * b) = a * (↑f b + ↑g b)
[PROOFSTEP]
simp [map_mul_left, mul_add]
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
f g : CentroidHom α
src✝ : α →+ α := ↑f + ↑g
a b : α
⊢ ZeroHom.toFun
      (↑{ toZeroHom := ↑src✝,
          map_add' :=
            (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
      (a * b) =
    ZeroHom.toFun
        (↑{ toZeroHom := ↑src✝,
            map_add' :=
              (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
        a *
      b
[PROOFSTEP]
show f (a * b) + g (a * b) = (f a + g a) * b
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
f g : CentroidHom α
src✝ : α →+ α := ↑f + ↑g
a b : α
⊢ ↑f (a * b) + ↑g (a * b) = (↑f a + ↑g a) * b
[PROOFSTEP]
simp [map_mul_right, add_mul]
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
n : ℕ
f : CentroidHom α
src✝ : α →+ α := SMul.smul n ↑f
a b : α
⊢ ZeroHom.toFun
      (↑{ toZeroHom := ↑src✝,
          map_add' :=
            (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
      (a * b) =
    a *
      ZeroHom.toFun
        (↑{ toZeroHom := ↑src✝,
            map_add' :=
              (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
        b
[PROOFSTEP]
change n • f (a * b) = a * n • f b
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
n : ℕ
f : CentroidHom α
src✝ : α →+ α := SMul.smul n ↑f
a b : α
⊢ n • ↑f (a * b) = a * n • ↑f b
[PROOFSTEP]
rw [map_mul_left f, ← mul_smul_comm]
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
n : ℕ
f : CentroidHom α
src✝ : α →+ α := SMul.smul n ↑f
a b : α
⊢ ZeroHom.toFun
      (↑{ toZeroHom := ↑src✝,
          map_add' :=
            (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
      (a * b) =
    ZeroHom.toFun
        (↑{ toZeroHom := ↑src✝,
            map_add' :=
              (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
        a *
      b
[PROOFSTEP]
change n • f (a * b) = n • f a * b
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
n : ℕ
f : CentroidHom α
src✝ : α →+ α := SMul.smul n ↑f
a b : α
⊢ n • ↑f (a * b) = n • ↑f a * b
[PROOFSTEP]
rw [map_mul_right f, ← smul_mul_assoc]
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
f : CentroidHom α
n : ℕ
src✝ : AddMonoid.End α := toEnd f ^ n
a b : α
⊢ ZeroHom.toFun
      (↑{ toZeroHom := ↑src✝,
          map_add' :=
            (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
      (a * b) =
    a *
      ZeroHom.toFun
        (↑{ toZeroHom := ↑src✝,
            map_add' :=
              (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
        b
[PROOFSTEP]
induction' n with n ih
[GOAL]
case zero
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
f : CentroidHom α
n : ℕ
src✝¹ : AddMonoid.End α := toEnd f ^ n
a b : α
src✝ : AddMonoid.End α := toEnd f ^ Nat.zero
⊢ ZeroHom.toFun
      (↑{ toZeroHom := ↑src✝,
          map_add' :=
            (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
      (a * b) =
    a *
      ZeroHom.toFun
        (↑{ toZeroHom := ↑src✝,
            map_add' :=
              (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
        b
[PROOFSTEP]
exact rfl
[GOAL]
case succ
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
f : CentroidHom α
n✝ : ℕ
src✝¹ : AddMonoid.End α := toEnd f ^ n✝
a b : α
n : ℕ
ih :
  let src := toEnd f ^ n;
  ZeroHom.toFun
      (↑{ toZeroHom := ↑src,
          map_add' :=
            (_ : ∀ (x y : α), ZeroHom.toFun (↑src) (x + y) = ZeroHom.toFun (↑src) x + ZeroHom.toFun (↑src) y) })
      (a * b) =
    a *
      ZeroHom.toFun
        (↑{ toZeroHom := ↑src,
            map_add' :=
              (_ : ∀ (x y : α), ZeroHom.toFun (↑src) (x + y) = ZeroHom.toFun (↑src) x + ZeroHom.toFun (↑src) y) })
        b
src✝ : AddMonoid.End α := toEnd f ^ Nat.succ n
⊢ ZeroHom.toFun
      (↑{ toZeroHom := ↑src✝,
          map_add' :=
            (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
      (a * b) =
    a *
      ZeroHom.toFun
        (↑{ toZeroHom := ↑src✝,
            map_add' :=
              (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
        b
[PROOFSTEP]
simp
[GOAL]
case succ
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
f : CentroidHom α
n✝ : ℕ
src✝¹ : AddMonoid.End α := toEnd f ^ n✝
a b : α
n : ℕ
ih :
  let src := toEnd f ^ n;
  ZeroHom.toFun
      (↑{ toZeroHom := ↑src,
          map_add' :=
            (_ : ∀ (x y : α), ZeroHom.toFun (↑src) (x + y) = ZeroHom.toFun (↑src) x + ZeroHom.toFun (↑src) y) })
      (a * b) =
    a *
      ZeroHom.toFun
        (↑{ toZeroHom := ↑src,
            map_add' :=
              (_ : ∀ (x y : α), ZeroHom.toFun (↑src) (x + y) = ZeroHom.toFun (↑src) x + ZeroHom.toFun (↑src) y) })
        b
src✝ : AddMonoid.End α := toEnd f ^ Nat.succ n
⊢ ↑(toEnd f ^ Nat.succ n) (a * b) = a * ↑(toEnd f ^ Nat.succ n) b
[PROOFSTEP]
rw [pow_succ]
[GOAL]
case succ
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
f : CentroidHom α
n✝ : ℕ
src✝¹ : AddMonoid.End α := toEnd f ^ n✝
a b : α
n : ℕ
ih :
  let src := toEnd f ^ n;
  ZeroHom.toFun
      (↑{ toZeroHom := ↑src,
          map_add' :=
            (_ : ∀ (x y : α), ZeroHom.toFun (↑src) (x + y) = ZeroHom.toFun (↑src) x + ZeroHom.toFun (↑src) y) })
      (a * b) =
    a *
      ZeroHom.toFun
        (↑{ toZeroHom := ↑src,
            map_add' :=
              (_ : ∀ (x y : α), ZeroHom.toFun (↑src) (x + y) = ZeroHom.toFun (↑src) x + ZeroHom.toFun (↑src) y) })
        b
src✝ : AddMonoid.End α := toEnd f ^ Nat.succ n
⊢ ↑(toEnd f * toEnd f ^ n) (a * b) = a * ↑(toEnd f * toEnd f ^ n) b
[PROOFSTEP]
exact (congr_arg f.toEnd ih).trans (f.map_mul_left' _ _)
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
f : CentroidHom α
n : ℕ
src✝ : AddMonoid.End α := toEnd f ^ n
a b : α
⊢ ZeroHom.toFun
      (↑{ toZeroHom := ↑src✝,
          map_add' :=
            (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
      (a * b) =
    ZeroHom.toFun
        (↑{ toZeroHom := ↑src✝,
            map_add' :=
              (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
        a *
      b
[PROOFSTEP]
induction' n with n ih
[GOAL]
case zero
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
f : CentroidHom α
n : ℕ
src✝¹ : AddMonoid.End α := toEnd f ^ n
a b : α
src✝ : AddMonoid.End α := toEnd f ^ Nat.zero
⊢ ZeroHom.toFun
      (↑{ toZeroHom := ↑src✝,
          map_add' :=
            (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
      (a * b) =
    ZeroHom.toFun
        (↑{ toZeroHom := ↑src✝,
            map_add' :=
              (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
        a *
      b
[PROOFSTEP]
exact rfl
[GOAL]
case succ
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
f : CentroidHom α
n✝ : ℕ
src✝¹ : AddMonoid.End α := toEnd f ^ n✝
a b : α
n : ℕ
ih :
  let src := toEnd f ^ n;
  ZeroHom.toFun
      (↑{ toZeroHom := ↑src,
          map_add' :=
            (_ : ∀ (x y : α), ZeroHom.toFun (↑src) (x + y) = ZeroHom.toFun (↑src) x + ZeroHom.toFun (↑src) y) })
      (a * b) =
    ZeroHom.toFun
        (↑{ toZeroHom := ↑src,
            map_add' :=
              (_ : ∀ (x y : α), ZeroHom.toFun (↑src) (x + y) = ZeroHom.toFun (↑src) x + ZeroHom.toFun (↑src) y) })
        a *
      b
src✝ : AddMonoid.End α := toEnd f ^ Nat.succ n
⊢ ZeroHom.toFun
      (↑{ toZeroHom := ↑src✝,
          map_add' :=
            (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
      (a * b) =
    ZeroHom.toFun
        (↑{ toZeroHom := ↑src✝,
            map_add' :=
              (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
        a *
      b
[PROOFSTEP]
simp
[GOAL]
case succ
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
f : CentroidHom α
n✝ : ℕ
src✝¹ : AddMonoid.End α := toEnd f ^ n✝
a b : α
n : ℕ
ih :
  let src := toEnd f ^ n;
  ZeroHom.toFun
      (↑{ toZeroHom := ↑src,
          map_add' :=
            (_ : ∀ (x y : α), ZeroHom.toFun (↑src) (x + y) = ZeroHom.toFun (↑src) x + ZeroHom.toFun (↑src) y) })
      (a * b) =
    ZeroHom.toFun
        (↑{ toZeroHom := ↑src,
            map_add' :=
              (_ : ∀ (x y : α), ZeroHom.toFun (↑src) (x + y) = ZeroHom.toFun (↑src) x + ZeroHom.toFun (↑src) y) })
        a *
      b
src✝ : AddMonoid.End α := toEnd f ^ Nat.succ n
⊢ ↑(toEnd f ^ Nat.succ n) (a * b) = ↑(toEnd f ^ Nat.succ n) a * b
[PROOFSTEP]
rw [pow_succ]
[GOAL]
case succ
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
f : CentroidHom α
n✝ : ℕ
src✝¹ : AddMonoid.End α := toEnd f ^ n✝
a b : α
n : ℕ
ih :
  let src := toEnd f ^ n;
  ZeroHom.toFun
      (↑{ toZeroHom := ↑src,
          map_add' :=
            (_ : ∀ (x y : α), ZeroHom.toFun (↑src) (x + y) = ZeroHom.toFun (↑src) x + ZeroHom.toFun (↑src) y) })
      (a * b) =
    ZeroHom.toFun
        (↑{ toZeroHom := ↑src,
            map_add' :=
              (_ : ∀ (x y : α), ZeroHom.toFun (↑src) (x + y) = ZeroHom.toFun (↑src) x + ZeroHom.toFun (↑src) y) })
        a *
      b
src✝ : AddMonoid.End α := toEnd f ^ Nat.succ n
⊢ ↑(toEnd f * toEnd f ^ n) (a * b) = ↑(toEnd f * toEnd f ^ n) a * b
[PROOFSTEP]
exact (congr_arg f.toEnd ih).trans (f.map_mul_right' _ _)
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
T S : CentroidHom α
a b : α
⊢ (↑T ∘ ↑S) (a * b) = (↑S ∘ ↑T) (a * b)
[PROOFSTEP]
simp
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
T S : CentroidHom α
a b : α
⊢ ↑T (↑S (a * b)) = ↑S (↑T (a * b))
[PROOFSTEP]
rw [map_mul_right, map_mul_left, ← map_mul_right, ← map_mul_left]
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocRing α
f : CentroidHom α
src✝ : α →+ α := -↑f
a b : α
⊢ ZeroHom.toFun
      (↑{ toZeroHom := ↑src✝,
          map_add' :=
            (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
      (a * b) =
    a *
      ZeroHom.toFun
        (↑{ toZeroHom := ↑src✝,
            map_add' :=
              (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
        b
[PROOFSTEP]
change -f (a * b) = a * (-f b)
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocRing α
f : CentroidHom α
src✝ : α →+ α := -↑f
a b : α
⊢ -↑f (a * b) = a * -↑f b
[PROOFSTEP]
simp [map_mul_left]
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocRing α
f : CentroidHom α
src✝ : α →+ α := -↑f
a b : α
⊢ ZeroHom.toFun
      (↑{ toZeroHom := ↑src✝,
          map_add' :=
            (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
      (a * b) =
    ZeroHom.toFun
        (↑{ toZeroHom := ↑src✝,
            map_add' :=
              (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
        a *
      b
[PROOFSTEP]
change -f (a * b) = (-f a) * b
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocRing α
f : CentroidHom α
src✝ : α →+ α := -↑f
a b : α
⊢ -↑f (a * b) = -↑f a * b
[PROOFSTEP]
simp [map_mul_right]
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocRing α
f g : CentroidHom α
src✝ : α →+ α := ↑f - ↑g
a b : α
⊢ ZeroHom.toFun
      (↑{ toZeroHom := ↑src✝,
          map_add' :=
            (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
      (a * b) =
    a *
      ZeroHom.toFun
        (↑{ toZeroHom := ↑src✝,
            map_add' :=
              (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
        b
[PROOFSTEP]
change (FunLike.coe f - FunLike.coe g) (a * b) = a * (FunLike.coe f - FunLike.coe g) b
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocRing α
f g : CentroidHom α
src✝ : α →+ α := ↑f - ↑g
a b : α
⊢ (↑f - ↑g) (a * b) = a * (↑f - ↑g) b
[PROOFSTEP]
simp [map_mul_left, mul_sub]
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocRing α
f g : CentroidHom α
src✝ : α →+ α := ↑f - ↑g
a b : α
⊢ ZeroHom.toFun
      (↑{ toZeroHom := ↑src✝,
          map_add' :=
            (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
      (a * b) =
    ZeroHom.toFun
        (↑{ toZeroHom := ↑src✝,
            map_add' :=
              (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
        a *
      b
[PROOFSTEP]
change (FunLike.coe f - FunLike.coe g) (a * b) = ((FunLike.coe f - FunLike.coe g) a) * b
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocRing α
f g : CentroidHom α
src✝ : α →+ α := ↑f - ↑g
a b : α
⊢ (↑f - ↑g) (a * b) = (↑f - ↑g) a * b
[PROOFSTEP]
simp [map_mul_right, sub_mul]
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocRing α
n : ℤ
f : CentroidHom α
src✝ : α →+ α := SMul.smul n ↑f
a b : α
⊢ ZeroHom.toFun
      (↑{ toZeroHom := ↑src✝,
          map_add' :=
            (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
      (a * b) =
    a *
      ZeroHom.toFun
        (↑{ toZeroHom := ↑src✝,
            map_add' :=
              (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
        b
[PROOFSTEP]
change n • f (a * b) = a * n • f b
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocRing α
n : ℤ
f : CentroidHom α
src✝ : α →+ α := SMul.smul n ↑f
a b : α
⊢ n • ↑f (a * b) = a * n • ↑f b
[PROOFSTEP]
rw [map_mul_left f, ← mul_smul_comm]
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocRing α
n : ℤ
f : CentroidHom α
src✝ : α →+ α := SMul.smul n ↑f
a b : α
⊢ ZeroHom.toFun
      (↑{ toZeroHom := ↑src✝,
          map_add' :=
            (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
      (a * b) =
    ZeroHom.toFun
        (↑{ toZeroHom := ↑src✝,
            map_add' :=
              (_ : ∀ (x y : α), ZeroHom.toFun (↑src✝) (x + y) = ZeroHom.toFun (↑src✝) x + ZeroHom.toFun (↑src✝) y) })
        a *
      b
[PROOFSTEP]
change n • f (a * b) = n • f a * b
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalNonAssocRing α
n : ℤ
f : CentroidHom α
src✝ : α →+ α := SMul.smul n ↑f
a b : α
⊢ n • ↑f (a * b) = n • ↑f a * b
[PROOFSTEP]
rw [map_mul_right f, ← smul_mul_assoc]
[GOAL]
F : Type u_1
α : Type u_2
inst✝ : NonUnitalRing α
h : ∀ (a b : α), (∀ (r : α), a * r * b = 0) → a = 0 ∨ b = 0
src✝ : Ring (CentroidHom α) := instRing
f g : CentroidHom α
⊢ f * g = g * f
[PROOFSTEP]
ext
[GOAL]
case h
F : Type u_1
α : Type u_2
inst✝ : NonUnitalRing α
h : ∀ (a b : α), (∀ (r : α), a * r * b = 0) → a = 0 ∨ b = 0
src✝ : Ring (CentroidHom α) := instRing
f g : CentroidHom α
a✝ : α
⊢ ↑(f * g) a✝ = ↑(g * f) a✝
[PROOFSTEP]
refine' sub_eq_zero.1 ((or_self_iff _).1 <| (h _ _) fun r ↦ _)
[GOAL]
case h
F : Type u_1
α : Type u_2
inst✝ : NonUnitalRing α
h : ∀ (a b : α), (∀ (r : α), a * r * b = 0) → a = 0 ∨ b = 0
src✝ : Ring (CentroidHom α) := instRing
f g : CentroidHom α
a✝ r : α
⊢ (↑(f * g) a✝ - ↑(g * f) a✝) * r * (↑(f * g) a✝ - ↑(g * f) a✝) = 0
[PROOFSTEP]
rw [mul_assoc, sub_mul, sub_eq_zero, ← map_mul_right, ← map_mul_right, coe_mul, coe_mul, comp_mul_comm]