[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
X✝ Y✝ : C
F : C ⥤ D
inst✝ : Full F
X Y : C
f : F.obj X ⟶ F.obj Y
⊢ F.map (F.preimage f) = f
[PROOFSTEP]
unfold preimage
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
X✝ Y✝ : C
F : C ⥤ D
inst✝ : Full F
X Y : C
f : F.obj X ⟶ F.obj Y
⊢ F.map (Full.preimage f) = f
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y : C
F : C ⥤ D
h : ∀ (X Y : C) (f : F.obj X ⟶ F.obj Y), ∃ p, F.map p = f
⊢ Full F
[PROOFSTEP]
choose p hp using h
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y : C
F : C ⥤ D
p : (X Y : C) → (F.obj X ⟶ F.obj Y) → (X ⟶ Y)
hp : ∀ (X Y : C) (f : F.obj X ⟶ F.obj Y), F.map (p X Y f) = f
⊢ Full F
[PROOFSTEP]
exact ⟨@p, @hp⟩
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
inst✝¹ : Full F
inst✝ : Faithful F
X Y Z : C
⊢ F.map (F.preimage (𝟙 (F.obj X))) = F.map (𝟙 X)
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
inst✝¹ : Full F
inst✝ : Faithful F
X Y Z : C
f : F.obj X ⟶ F.obj Y
g : F.obj Y ⟶ F.obj Z
⊢ F.map (F.preimage (f ≫ g)) = F.map (F.preimage f ≫ F.preimage g)
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
inst✝¹ : Full F
inst✝ : Faithful F
X Y Z : C
f : X ⟶ Y
⊢ F.map (F.preimage (F.map f)) = F.map f
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
inst✝¹ : Full F
inst✝ : Faithful F
X Y Z : C
f : F.obj X ≅ F.obj Y
⊢ F.map (F.preimage f.hom ≫ F.preimage f.inv) = F.map (𝟙 X)
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
inst✝¹ : Full F
inst✝ : Faithful F
X Y Z : C
f : F.obj X ≅ F.obj Y
⊢ F.map (F.preimage f.inv ≫ F.preimage f.hom) = F.map (𝟙 Y)
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
inst✝¹ : Full F
inst✝ : Faithful F
X Y Z : C
f : X ≅ Y
⊢ preimageIso F (F.mapIso f) = f
[PROOFSTEP]
ext
[GOAL]
case w
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
inst✝¹ : Full F
inst✝ : Faithful F
X Y Z : C
f : X ≅ Y
⊢ (preimageIso F (F.mapIso f)).hom = f.hom
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : Full F
inst✝¹ : Faithful F
X Y Z : C
f : X ⟶ Y
inst✝ : IsIso (F.map f)
⊢ F.map (f ≫ F.preimage (inv (F.map f))) = F.map (𝟙 X)
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : Full F
inst✝¹ : Faithful F
X Y Z : C
f : X ⟶ Y
inst✝ : IsIso (F.map f)
⊢ F.map (F.preimage (inv (F.map f)) ≫ f) = F.map (𝟙 Y)
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
inst✝¹ : Full F
inst✝ : Faithful F
X✝ Y✝ Z X Y : C
f : X ⟶ Y
⊢ (fun f => F.preimage f) ((fun f => F.map f) f) = f
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
inst✝¹ : Full F
inst✝ : Faithful F
X✝ Y✝ Z X Y : C
f : F.obj X ⟶ F.obj Y
⊢ (fun f => F.map f) ((fun f => F.preimage f) f) = f
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
inst✝¹ : Full F
inst✝ : Faithful F
X✝ Y✝ Z X Y : C
f : X ≅ Y
⊢ (fun f => Functor.preimageIso F f) ((fun f => F.mapIso f) f) = f
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
inst✝¹ : Full F
inst✝ : Faithful F
X✝ Y✝ Z X Y : C
f : F.obj X ≅ F.obj Y
⊢ (fun f => F.mapIso f) ((fun f => Functor.preimageIso F f) f) = f
[PROOFSTEP]
ext
[GOAL]
case w
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
inst✝¹ : Full F
inst✝ : Faithful F
X✝ Y✝ Z X Y : C
f : F.obj X ≅ F.obj Y
⊢ ((fun f => F.mapIso f) ((fun f => Functor.preimageIso F f) f)).hom = f.hom
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u_1
inst✝² : Category.{?u.9765, u_1} E
F G : C ⥤ D
H : D ⥤ E
inst✝¹ : Full H
inst✝ : Faithful H
α : F ⋙ H ⟶ G ⋙ H
X Y : C
f : X ⟶ Y
⊢ F.map f ≫ (fun X => ↑(equivOfFullyFaithful H).symm (NatTrans.app α X)) Y =
    (fun X => ↑(equivOfFullyFaithful H).symm (NatTrans.app α X)) X ≫ G.map f
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u_1
inst✝² : Category.{?u.9765, u_1} E
F G : C ⥤ D
H : D ⥤ E
inst✝¹ : Full H
inst✝ : Faithful H
α : F ⋙ H ⟶ G ⋙ H
X Y : C
f : X ⟶ Y
⊢ F.map f ≫ H.preimage (NatTrans.app α Y) = H.preimage (NatTrans.app α X) ≫ G.map f
[PROOFSTEP]
apply H.map_injective
[GOAL]
case a
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u_1
inst✝² : Category.{?u.9765, u_1} E
F G : C ⥤ D
H : D ⥤ E
inst✝¹ : Full H
inst✝ : Faithful H
α : F ⋙ H ⟶ G ⋙ H
X Y : C
f : X ⟶ Y
⊢ H.map (F.map f ≫ H.preimage (NatTrans.app α Y)) = H.map (H.preimage (NatTrans.app α X) ≫ G.map f)
[PROOFSTEP]
simpa using α.naturality f
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u_1
inst✝² : Category.{?u.11855, u_1} E
F G : C ⥤ D
H : D ⥤ E
inst✝¹ : Full H
inst✝ : Faithful H
i : F ⋙ H ≅ G ⋙ H
X✝ Y✝ : C
f : X✝ ⟶ Y✝
⊢ F.map f ≫ ((fun X => ↑(isoEquivOfFullyFaithful H).symm (i.app X)) Y✝).hom =
    ((fun X => ↑(isoEquivOfFullyFaithful H).symm (i.app X)) X✝).hom ≫ G.map f
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u_1
inst✝² : Category.{?u.11855, u_1} E
F G : C ⥤ D
H : D ⥤ E
inst✝¹ : Full H
inst✝ : Faithful H
i : F ⋙ H ≅ G ⋙ H
X✝ Y✝ : C
f : X✝ ⟶ Y✝
⊢ F.map f ≫ H.preimage (NatTrans.app i.hom Y✝) = H.preimage (NatTrans.app i.hom X✝) ≫ G.map f
[PROOFSTEP]
apply H.map_injective
[GOAL]
case a
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u_1
inst✝² : Category.{?u.11855, u_1} E
F G : C ⥤ D
H : D ⥤ E
inst✝¹ : Full H
inst✝ : Faithful H
i : F ⋙ H ≅ G ⋙ H
X✝ Y✝ : C
f : X✝ ⟶ Y✝
⊢ H.map (F.map f ≫ H.preimage (NatTrans.app i.hom Y✝)) = H.map (H.preimage (NatTrans.app i.hom X✝) ≫ G.map f)
[PROOFSTEP]
simpa using i.hom.naturality f
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u_1
inst✝² : Category.{u_2, u_1} E
F G : C ⥤ D
H : D ⥤ E
inst✝¹ : Full H
inst✝ : Faithful H
i : F ⋙ H ≅ G ⋙ H
⊢ (natIsoOfCompFullyFaithful H i).hom = natTransOfCompFullyFaithful H i.hom
[PROOFSTEP]
ext
[GOAL]
case w.h
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u_1
inst✝² : Category.{u_2, u_1} E
F G : C ⥤ D
H : D ⥤ E
inst✝¹ : Full H
inst✝ : Faithful H
i : F ⋙ H ≅ G ⋙ H
x✝ : C
⊢ NatTrans.app (natIsoOfCompFullyFaithful H i).hom x✝ = NatTrans.app (natTransOfCompFullyFaithful H i.hom) x✝
[PROOFSTEP]
simp [natIsoOfCompFullyFaithful]
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u_1
inst✝² : Category.{u_2, u_1} E
F G : C ⥤ D
H : D ⥤ E
inst✝¹ : Full H
inst✝ : Faithful H
i : F ⋙ H ≅ G ⋙ H
⊢ (natIsoOfCompFullyFaithful H i).inv = natTransOfCompFullyFaithful H i.inv
[PROOFSTEP]
ext
[GOAL]
case w.h
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u_1
inst✝² : Category.{u_2, u_1} E
F G : C ⥤ D
H : D ⥤ E
inst✝¹ : Full H
inst✝ : Faithful H
i : F ⋙ H ≅ G ⋙ H
x✝ : C
⊢ NatTrans.app (natIsoOfCompFullyFaithful H i).inv x✝ = NatTrans.app (natTransOfCompFullyFaithful H i.inv) x✝
[PROOFSTEP]
simp [← preimage_comp]
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u_1
inst✝² : Category.{?u.17323, u_1} E
F G : C ⥤ D
H : D ⥤ E
inst✝¹ : Full H
inst✝ : Faithful H
⊢ Function.LeftInverse (natTransOfCompFullyFaithful H) fun α => α ◫ 𝟙 H
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u_1
inst✝² : Category.{?u.17323, u_1} E
F G : C ⥤ D
H : D ⥤ E
inst✝¹ : Full H
inst✝ : Faithful H
⊢ Function.RightInverse (natTransOfCompFullyFaithful H) fun α => α ◫ 𝟙 H
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u_1
inst✝² : Category.{?u.20694, u_1} E
F G : C ⥤ D
H : D ⥤ E
inst✝¹ : Full H
inst✝ : Faithful H
⊢ Function.LeftInverse (natIsoOfCompFullyFaithful H) fun e => hcomp e (Iso.refl H)
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u_1
inst✝² : Category.{?u.20694, u_1} E
F G : C ⥤ D
H : D ⥤ E
inst✝¹ : Full H
inst✝ : Faithful H
⊢ Function.RightInverse (natIsoOfCompFullyFaithful H) fun e => hcomp e (Iso.refl H)
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F F' : C ⥤ D
G : D ⥤ E
inst✝ : Full F
α : F ≅ F'
X✝ Y✝ : C
f : F'.obj X✝ ⟶ F'.obj Y✝
⊢ F'.map ((fun {X Y} f => F.preimage ((α.app X).hom ≫ f ≫ (α.app Y).inv)) f) = f
[PROOFSTEP]
simp [← NatIso.naturality_1 α]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F F' : C ⥤ D
G : D ⥤ E
inst✝ : Faithful F
α : F ≅ F'
X✝ Y✝ : C
a₁✝ a₂✝ : X✝ ⟶ Y✝
h : F'.map a₁✝ = F'.map a₂✝
⊢ F.map a₁✝ = F.map a₂✝
[PROOFSTEP]
rw [← NatIso.naturality_1 α.symm, h, NatIso.naturality_1 α.symm]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
⊢ ∀ (X : C), { obj := obj, map := map }.map (𝟙 X) = 𝟙 ({ obj := obj, map := map }.obj X)
[PROOFSTEP]
intros X
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X : C
⊢ { obj := obj, map := map }.map (𝟙 X) = 𝟙 ({ obj := obj, map := map }.obj X)
[PROOFSTEP]
apply G.map_injective
[GOAL]
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X : C
⊢ G.map ({ obj := obj, map := map }.map (𝟙 X)) = G.map (𝟙 ({ obj := obj, map := map }.obj X))
[PROOFSTEP]
apply eq_of_heq
[GOAL]
case a.h
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X : C
⊢ HEq (G.map ({ obj := obj, map := map }.map (𝟙 X))) (G.map (𝟙 ({ obj := obj, map := map }.obj X)))
[PROOFSTEP]
trans F.map (𝟙 X)
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X : C
⊢ HEq (G.map ({ obj := obj, map := map }.map (𝟙 X))) (F.map (𝟙 X))
[PROOFSTEP]
exact h_map
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X : C
⊢ HEq (F.map (𝟙 X)) (G.map (𝟙 ({ obj := obj, map := map }.obj X)))
[PROOFSTEP]
rw [F.map_id, G.map_id, h_obj X]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
⊢ ∀ {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
    { obj := obj, map := map }.map (f ≫ g) = { obj := obj, map := map }.map f ≫ { obj := obj, map := map }.map g
[PROOFSTEP]
intros X Y Z f g
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ { obj := obj, map := map }.map (f ≫ g) = { obj := obj, map := map }.map f ≫ { obj := obj, map := map }.map g
[PROOFSTEP]
refine G.map_injective <| eq_of_heq <| h_map.trans ?_
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ HEq (F.map (f ≫ g)) (G.map ({ obj := obj, map := map }.map f ≫ { obj := obj, map := map }.map g))
[PROOFSTEP]
simp only [Functor.map_comp]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ HEq (F.map f ≫ F.map g) (G.map (map f) ≫ G.map (map g))
[PROOFSTEP]
convert HEq.refl (F.map f ≫ F.map g)
[GOAL]
case h.e'_3.h.e'_3
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ G.obj (obj X) = F.obj X
case h.e'_3.h.e'_4
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ G.obj (obj Z) = F.obj Z
case h.e'_4.e'_3
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
e_3✝ : (G.obj (obj X) ⟶ G.obj (obj Z)) = (F.obj X ⟶ F.obj Z)
⊢ G.obj (obj X) = F.obj X
case h.e'_4.e'_4
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
e_3✝ : (G.obj (obj X) ⟶ G.obj (obj Z)) = (F.obj X ⟶ F.obj Z)
⊢ G.obj (obj Y) = F.obj Y
case h.e'_4.e'_5
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
e_3✝ : (G.obj (obj X) ⟶ G.obj (obj Z)) = (F.obj X ⟶ F.obj Z)
⊢ G.obj (obj Z) = F.obj Z
case h.e'_4.e'_6
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
e_3✝¹ : (G.obj (obj X) ⟶ G.obj (obj Z)) = (F.obj X ⟶ F.obj Z)
e_3✝ : G.obj (obj X) = F.obj X
e_4✝ : G.obj (obj Y) = F.obj Y
⊢ HEq (G.map (map f)) (F.map f)
case h.e'_4.e'_7
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
e_3✝ : (G.obj (obj X) ⟶ G.obj (obj Z)) = (F.obj X ⟶ F.obj Z)
e_4✝ : G.obj (obj Y) = F.obj Y
e_5✝ : G.obj (obj Z) = F.obj Z
⊢ HEq (G.map (map g)) (F.map g)
[PROOFSTEP]
all_goals
  {first
  | apply h_obj
  | apply h_map
}
[GOAL]
case h.e'_3.h.e'_3
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ G.obj (obj X) = F.obj X
[PROOFSTEP]
{first
  | apply h_obj
  | apply h_map
}
[GOAL]
case h.e'_3.h.e'_3
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ G.obj (obj X) = F.obj X
[PROOFSTEP]
first
| apply h_obj
| apply h_map
[GOAL]
case h.e'_3.h.e'_3
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ G.obj (obj X) = F.obj X
[PROOFSTEP]
apply h_obj
[GOAL]
case h.e'_3.h.e'_4
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ G.obj (obj Z) = F.obj Z
[PROOFSTEP]
{first
  | apply h_obj
  | apply h_map
}
[GOAL]
case h.e'_3.h.e'_4
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ G.obj (obj Z) = F.obj Z
[PROOFSTEP]
first
| apply h_obj
| apply h_map
[GOAL]
case h.e'_3.h.e'_4
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ G.obj (obj Z) = F.obj Z
[PROOFSTEP]
apply h_obj
[GOAL]
case h.e'_4.e'_3
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
e_3✝ : (G.obj (obj X) ⟶ G.obj (obj Z)) = (F.obj X ⟶ F.obj Z)
⊢ G.obj (obj X) = F.obj X
[PROOFSTEP]
{first
  | apply h_obj
  | apply h_map
}
[GOAL]
case h.e'_4.e'_3
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
e_3✝ : (G.obj (obj X) ⟶ G.obj (obj Z)) = (F.obj X ⟶ F.obj Z)
⊢ G.obj (obj X) = F.obj X
[PROOFSTEP]
first
| apply h_obj
| apply h_map
[GOAL]
case h.e'_4.e'_3
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
e_3✝ : (G.obj (obj X) ⟶ G.obj (obj Z)) = (F.obj X ⟶ F.obj Z)
⊢ G.obj (obj X) = F.obj X
[PROOFSTEP]
apply h_obj
[GOAL]
case h.e'_4.e'_4
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
e_3✝ : (G.obj (obj X) ⟶ G.obj (obj Z)) = (F.obj X ⟶ F.obj Z)
⊢ G.obj (obj Y) = F.obj Y
[PROOFSTEP]
{first
  | apply h_obj
  | apply h_map
}
[GOAL]
case h.e'_4.e'_4
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
e_3✝ : (G.obj (obj X) ⟶ G.obj (obj Z)) = (F.obj X ⟶ F.obj Z)
⊢ G.obj (obj Y) = F.obj Y
[PROOFSTEP]
first
| apply h_obj
| apply h_map
[GOAL]
case h.e'_4.e'_4
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
e_3✝ : (G.obj (obj X) ⟶ G.obj (obj Z)) = (F.obj X ⟶ F.obj Z)
⊢ G.obj (obj Y) = F.obj Y
[PROOFSTEP]
apply h_obj
[GOAL]
case h.e'_4.e'_5
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
e_3✝ : (G.obj (obj X) ⟶ G.obj (obj Z)) = (F.obj X ⟶ F.obj Z)
⊢ G.obj (obj Z) = F.obj Z
[PROOFSTEP]
{first
  | apply h_obj
  | apply h_map
}
[GOAL]
case h.e'_4.e'_5
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
e_3✝ : (G.obj (obj X) ⟶ G.obj (obj Z)) = (F.obj X ⟶ F.obj Z)
⊢ G.obj (obj Z) = F.obj Z
[PROOFSTEP]
first
| apply h_obj
| apply h_map
[GOAL]
case h.e'_4.e'_5
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
e_3✝ : (G.obj (obj X) ⟶ G.obj (obj Z)) = (F.obj X ⟶ F.obj Z)
⊢ G.obj (obj Z) = F.obj Z
[PROOFSTEP]
apply h_obj
[GOAL]
case h.e'_4.e'_6
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
e_3✝¹ : (G.obj (obj X) ⟶ G.obj (obj Z)) = (F.obj X ⟶ F.obj Z)
e_3✝ : G.obj (obj X) = F.obj X
e_4✝ : G.obj (obj Y) = F.obj Y
⊢ HEq (G.map (map f)) (F.map f)
[PROOFSTEP]
{first
  | apply h_obj
  | apply h_map
}
[GOAL]
case h.e'_4.e'_6
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
e_3✝¹ : (G.obj (obj X) ⟶ G.obj (obj Z)) = (F.obj X ⟶ F.obj Z)
e_3✝ : G.obj (obj X) = F.obj X
e_4✝ : G.obj (obj Y) = F.obj Y
⊢ HEq (G.map (map f)) (F.map f)
[PROOFSTEP]
first
| apply h_obj
| apply h_map
[GOAL]
case h.e'_4.e'_6
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
e_3✝¹ : (G.obj (obj X) ⟶ G.obj (obj Z)) = (F.obj X ⟶ F.obj Z)
e_3✝ : G.obj (obj X) = F.obj X
e_4✝ : G.obj (obj Y) = F.obj Y
⊢ HEq (G.map (map f)) (F.map f)
[PROOFSTEP]
apply h_obj
[GOAL]
case h.e'_4.e'_6
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
e_3✝¹ : (G.obj (obj X) ⟶ G.obj (obj Z)) = (F.obj X ⟶ F.obj Z)
e_3✝ : G.obj (obj X) = F.obj X
e_4✝ : G.obj (obj Y) = F.obj Y
⊢ HEq (G.map (map f)) (F.map f)
[PROOFSTEP]
apply h_map
[GOAL]
case h.e'_4.e'_7
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
e_3✝ : (G.obj (obj X) ⟶ G.obj (obj Z)) = (F.obj X ⟶ F.obj Z)
e_4✝ : G.obj (obj Y) = F.obj Y
e_5✝ : G.obj (obj Z) = F.obj Z
⊢ HEq (G.map (map g)) (F.map g)
[PROOFSTEP]
{first
  | apply h_obj
  | apply h_map
}
[GOAL]
case h.e'_4.e'_7
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
e_3✝ : (G.obj (obj X) ⟶ G.obj (obj Z)) = (F.obj X ⟶ F.obj Z)
e_4✝ : G.obj (obj Y) = F.obj Y
e_5✝ : G.obj (obj Z) = F.obj Z
⊢ HEq (G.map (map g)) (F.map g)
[PROOFSTEP]
first
| apply h_obj
| apply h_map
[GOAL]
case h.e'_4.e'_7
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
e_3✝ : (G.obj (obj X) ⟶ G.obj (obj Z)) = (F.obj X ⟶ F.obj Z)
e_4✝ : G.obj (obj Y) = F.obj Y
e_5✝ : G.obj (obj Z) = F.obj Z
⊢ HEq (G.map (map g)) (F.map g)
[PROOFSTEP]
apply h_obj
[GOAL]
case h.e'_4.e'_7
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
e_3✝ : (G.obj (obj X) ⟶ G.obj (obj Z)) = (F.obj X ⟶ F.obj Z)
e_4✝ : G.obj (obj Y) = F.obj Y
e_5✝ : G.obj (obj Z) = F.obj Z
⊢ HEq (G.map (map g)) (F.map g)
[PROOFSTEP]
apply h_map
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F : C ⥤ E
inst✝¹ : Faithful F
G : D ⥤ E
inst✝ : Faithful G
obj : C → D
h_obj : ∀ (X : C), G.obj (obj X) = F.obj X
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)
⊢ Faithful.div F G obj h_obj map h_map ⋙ G = F
[PROOFSTEP]
cases' F with F_pre _ _
[GOAL]
case mk
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
F F' : C ⥤ D
G✝ G : D ⥤ E
inst✝¹ : Faithful G
obj : C → D
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
F_pre : C ⥤q E
map_id✝ : ∀ (X : C), F_pre.map (𝟙 X) = 𝟙 (F_pre.obj X)
map_comp✝ : ∀ {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z), F_pre.map (f ≫ g) = F_pre.map f ≫ F_pre.map g
inst✝ : Faithful (Functor.mk F_pre)
h_obj : ∀ (X : C), G.obj (obj X) = (Functor.mk F_pre).obj X
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) ((Functor.mk F_pre).map f)
⊢ Faithful.div (Functor.mk F_pre) G obj h_obj map h_map ⋙ G = Functor.mk F_pre
[PROOFSTEP]
cases' G with G_pre _ _
[GOAL]
case mk.mk
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
F F' : C ⥤ D
G : D ⥤ E
obj : C → D
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
F_pre : C ⥤q E
map_id✝¹ : ∀ (X : C), F_pre.map (𝟙 X) = 𝟙 (F_pre.obj X)
map_comp✝¹ : ∀ {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z), F_pre.map (f ≫ g) = F_pre.map f ≫ F_pre.map g
inst✝¹ : Faithful (Functor.mk F_pre)
G_pre : D ⥤q E
map_id✝ : ∀ (X : D), G_pre.map (𝟙 X) = 𝟙 (G_pre.obj X)
map_comp✝ : ∀ {X Y Z : D} (f : X ⟶ Y) (g : Y ⟶ Z), G_pre.map (f ≫ g) = G_pre.map f ≫ G_pre.map g
inst✝ : Faithful (Functor.mk G_pre)
h_obj : ∀ (X : C), (Functor.mk G_pre).obj (obj X) = (Functor.mk F_pre).obj X
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq ((Functor.mk G_pre).map (map f)) ((Functor.mk F_pre).map f)
⊢ Faithful.div (Functor.mk F_pre) (Functor.mk G_pre) obj h_obj map h_map ⋙ Functor.mk G_pre = Functor.mk F_pre
[PROOFSTEP]
cases' F_pre with F_obj _
[GOAL]
case mk.mk.mk
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
F F' : C ⥤ D
G : D ⥤ E
obj : C → D
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
G_pre : D ⥤q E
map_id✝¹ : ∀ (X : D), G_pre.map (𝟙 X) = 𝟙 (G_pre.obj X)
map_comp✝¹ : ∀ {X Y Z : D} (f : X ⟶ Y) (g : Y ⟶ Z), G_pre.map (f ≫ g) = G_pre.map f ≫ G_pre.map g
inst✝¹ : Faithful (Functor.mk G_pre)
F_obj : C → E
map✝ : {X Y : C} → (X ⟶ Y) → (F_obj X ⟶ F_obj Y)
map_id✝ : ∀ (X : C), { obj := F_obj, map := map✝ }.map (𝟙 X) = 𝟙 ({ obj := F_obj, map := map✝ }.obj X)
map_comp✝ :
  ∀ {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
    { obj := F_obj, map := map✝ }.map (f ≫ g) =
      { obj := F_obj, map := map✝ }.map f ≫ { obj := F_obj, map := map✝ }.map g
inst✝ : Faithful (Functor.mk { obj := F_obj, map := map✝ })
h_obj : ∀ (X : C), (Functor.mk G_pre).obj (obj X) = (Functor.mk { obj := F_obj, map := map✝ }).obj X
h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq ((Functor.mk G_pre).map (map f)) ((Functor.mk { obj := F_obj, map := map✝ }).map f)
⊢ Faithful.div (Functor.mk { obj := F_obj, map := map✝ }) (Functor.mk G_pre) obj h_obj map h_map ⋙ Functor.mk G_pre =
    Functor.mk { obj := F_obj, map := map✝ }
[PROOFSTEP]
cases' G_pre with G_obj _
[GOAL]
case mk.mk.mk.mk
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
F F' : C ⥤ D
G : D ⥤ E
obj : C → D
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
F_obj : C → E
map✝¹ : {X Y : C} → (X ⟶ Y) → (F_obj X ⟶ F_obj Y)
map_id✝¹ : ∀ (X : C), { obj := F_obj, map := map✝¹ }.map (𝟙 X) = 𝟙 ({ obj := F_obj, map := map✝¹ }.obj X)
map_comp✝¹ :
  ∀ {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
    { obj := F_obj, map := map✝¹ }.map (f ≫ g) =
      { obj := F_obj, map := map✝¹ }.map f ≫ { obj := F_obj, map := map✝¹ }.map g
inst✝¹ : Faithful (Functor.mk { obj := F_obj, map := map✝¹ })
G_obj : D → E
map✝ : {X Y : D} → (X ⟶ Y) → (G_obj X ⟶ G_obj Y)
map_id✝ : ∀ (X : D), { obj := G_obj, map := map✝ }.map (𝟙 X) = 𝟙 ({ obj := G_obj, map := map✝ }.obj X)
map_comp✝ :
  ∀ {X Y Z : D} (f : X ⟶ Y) (g : Y ⟶ Z),
    { obj := G_obj, map := map✝ }.map (f ≫ g) =
      { obj := G_obj, map := map✝ }.map f ≫ { obj := G_obj, map := map✝ }.map g
inst✝ : Faithful (Functor.mk { obj := G_obj, map := map✝ })
h_obj :
  ∀ (X : C), (Functor.mk { obj := G_obj, map := map✝ }).obj (obj X) = (Functor.mk { obj := F_obj, map := map✝¹ }).obj X
h_map :
  ∀ {X Y : C} {f : X ⟶ Y},
    HEq ((Functor.mk { obj := G_obj, map := map✝ }).map (map f)) ((Functor.mk { obj := F_obj, map := map✝¹ }).map f)
⊢ Faithful.div (Functor.mk { obj := F_obj, map := map✝¹ }) (Functor.mk { obj := G_obj, map := map✝ }) obj h_obj map
        h_map ⋙
      Functor.mk { obj := G_obj, map := map✝ } =
    Functor.mk { obj := F_obj, map := map✝¹ }
[PROOFSTEP]
unfold Faithful.div Functor.comp
[GOAL]
case mk.mk.mk.mk
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
F F' : C ⥤ D
G : D ⥤ E
obj : C → D
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
F_obj : C → E
map✝¹ : {X Y : C} → (X ⟶ Y) → (F_obj X ⟶ F_obj Y)
map_id✝¹ : ∀ (X : C), { obj := F_obj, map := map✝¹ }.map (𝟙 X) = 𝟙 ({ obj := F_obj, map := map✝¹ }.obj X)
map_comp✝¹ :
  ∀ {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
    { obj := F_obj, map := map✝¹ }.map (f ≫ g) =
      { obj := F_obj, map := map✝¹ }.map f ≫ { obj := F_obj, map := map✝¹ }.map g
inst✝¹ : Faithful (Functor.mk { obj := F_obj, map := map✝¹ })
G_obj : D → E
map✝ : {X Y : D} → (X ⟶ Y) → (G_obj X ⟶ G_obj Y)
map_id✝ : ∀ (X : D), { obj := G_obj, map := map✝ }.map (𝟙 X) = 𝟙 ({ obj := G_obj, map := map✝ }.obj X)
map_comp✝ :
  ∀ {X Y Z : D} (f : X ⟶ Y) (g : Y ⟶ Z),
    { obj := G_obj, map := map✝ }.map (f ≫ g) =
      { obj := G_obj, map := map✝ }.map f ≫ { obj := G_obj, map := map✝ }.map g
inst✝ : Faithful (Functor.mk { obj := G_obj, map := map✝ })
h_obj :
  ∀ (X : C), (Functor.mk { obj := G_obj, map := map✝ }).obj (obj X) = (Functor.mk { obj := F_obj, map := map✝¹ }).obj X
h_map :
  ∀ {X Y : C} {f : X ⟶ Y},
    HEq ((Functor.mk { obj := G_obj, map := map✝ }).map (map f)) ((Functor.mk { obj := F_obj, map := map✝¹ }).map f)
⊢ Functor.mk
      { obj := fun X => (Functor.mk { obj := G_obj, map := map✝ }).obj ((Functor.mk { obj := obj, map := map }).obj X),
        map := fun {X Y} f =>
          (Functor.mk { obj := G_obj, map := map✝ }).map ((Functor.mk { obj := obj, map := map }).map f) } =
    Functor.mk { obj := F_obj, map := map✝¹ }
[PROOFSTEP]
have : F_obj = G_obj ∘ obj := (funext h_obj).symm
[GOAL]
case mk.mk.mk.mk
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
F F' : C ⥤ D
G : D ⥤ E
obj : C → D
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
F_obj : C → E
map✝¹ : {X Y : C} → (X ⟶ Y) → (F_obj X ⟶ F_obj Y)
map_id✝¹ : ∀ (X : C), { obj := F_obj, map := map✝¹ }.map (𝟙 X) = 𝟙 ({ obj := F_obj, map := map✝¹ }.obj X)
map_comp✝¹ :
  ∀ {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
    { obj := F_obj, map := map✝¹ }.map (f ≫ g) =
      { obj := F_obj, map := map✝¹ }.map f ≫ { obj := F_obj, map := map✝¹ }.map g
inst✝¹ : Faithful (Functor.mk { obj := F_obj, map := map✝¹ })
G_obj : D → E
map✝ : {X Y : D} → (X ⟶ Y) → (G_obj X ⟶ G_obj Y)
map_id✝ : ∀ (X : D), { obj := G_obj, map := map✝ }.map (𝟙 X) = 𝟙 ({ obj := G_obj, map := map✝ }.obj X)
map_comp✝ :
  ∀ {X Y Z : D} (f : X ⟶ Y) (g : Y ⟶ Z),
    { obj := G_obj, map := map✝ }.map (f ≫ g) =
      { obj := G_obj, map := map✝ }.map f ≫ { obj := G_obj, map := map✝ }.map g
inst✝ : Faithful (Functor.mk { obj := G_obj, map := map✝ })
h_obj :
  ∀ (X : C), (Functor.mk { obj := G_obj, map := map✝ }).obj (obj X) = (Functor.mk { obj := F_obj, map := map✝¹ }).obj X
h_map :
  ∀ {X Y : C} {f : X ⟶ Y},
    HEq ((Functor.mk { obj := G_obj, map := map✝ }).map (map f)) ((Functor.mk { obj := F_obj, map := map✝¹ }).map f)
this : F_obj = G_obj ∘ obj
⊢ Functor.mk
      { obj := fun X => (Functor.mk { obj := G_obj, map := map✝ }).obj ((Functor.mk { obj := obj, map := map }).obj X),
        map := fun {X Y} f =>
          (Functor.mk { obj := G_obj, map := map✝ }).map ((Functor.mk { obj := obj, map := map }).map f) } =
    Functor.mk { obj := F_obj, map := map✝¹ }
[PROOFSTEP]
subst this
[GOAL]
case mk.mk.mk.mk
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
F F' : C ⥤ D
G : D ⥤ E
obj : C → D
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
G_obj : D → E
map✝¹ : {X Y : D} → (X ⟶ Y) → (G_obj X ⟶ G_obj Y)
map_id✝¹ : ∀ (X : D), { obj := G_obj, map := map✝¹ }.map (𝟙 X) = 𝟙 ({ obj := G_obj, map := map✝¹ }.obj X)
map_comp✝¹ :
  ∀ {X Y Z : D} (f : X ⟶ Y) (g : Y ⟶ Z),
    { obj := G_obj, map := map✝¹ }.map (f ≫ g) =
      { obj := G_obj, map := map✝¹ }.map f ≫ { obj := G_obj, map := map✝¹ }.map g
inst✝¹ : Faithful (Functor.mk { obj := G_obj, map := map✝¹ })
map✝ : {X Y : C} → (X ⟶ Y) → ((G_obj ∘ obj) X ⟶ (G_obj ∘ obj) Y)
map_id✝ : ∀ (X : C), { obj := G_obj ∘ obj, map := map✝ }.map (𝟙 X) = 𝟙 ({ obj := G_obj ∘ obj, map := map✝ }.obj X)
map_comp✝ :
  ∀ {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
    { obj := G_obj ∘ obj, map := map✝ }.map (f ≫ g) =
      { obj := G_obj ∘ obj, map := map✝ }.map f ≫ { obj := G_obj ∘ obj, map := map✝ }.map g
inst✝ : Faithful (Functor.mk { obj := G_obj ∘ obj, map := map✝ })
h_obj :
  ∀ (X : C),
    (Functor.mk { obj := G_obj, map := map✝¹ }).obj (obj X) = (Functor.mk { obj := G_obj ∘ obj, map := map✝ }).obj X
h_map :
  ∀ {X Y : C} {f : X ⟶ Y},
    HEq ((Functor.mk { obj := G_obj, map := map✝¹ }).map (map f))
      ((Functor.mk { obj := G_obj ∘ obj, map := map✝ }).map f)
⊢ Functor.mk
      { obj := fun X => (Functor.mk { obj := G_obj, map := map✝¹ }).obj ((Functor.mk { obj := obj, map := map }).obj X),
        map := fun {X Y} f =>
          (Functor.mk { obj := G_obj, map := map✝¹ }).map ((Functor.mk { obj := obj, map := map }).map f) } =
    Functor.mk { obj := G_obj ∘ obj, map := map✝ }
[PROOFSTEP]
congr
[GOAL]
case mk.mk.mk.mk.e_toPrefunctor.e_map
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
F F' : C ⥤ D
G : D ⥤ E
obj : C → D
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
G_obj : D → E
map✝¹ : {X Y : D} → (X ⟶ Y) → (G_obj X ⟶ G_obj Y)
map_id✝¹ : ∀ (X : D), { obj := G_obj, map := map✝¹ }.map (𝟙 X) = 𝟙 ({ obj := G_obj, map := map✝¹ }.obj X)
map_comp✝¹ :
  ∀ {X Y Z : D} (f : X ⟶ Y) (g : Y ⟶ Z),
    { obj := G_obj, map := map✝¹ }.map (f ≫ g) =
      { obj := G_obj, map := map✝¹ }.map f ≫ { obj := G_obj, map := map✝¹ }.map g
inst✝¹ : Faithful (Functor.mk { obj := G_obj, map := map✝¹ })
map✝ : {X Y : C} → (X ⟶ Y) → ((G_obj ∘ obj) X ⟶ (G_obj ∘ obj) Y)
map_id✝ : ∀ (X : C), { obj := G_obj ∘ obj, map := map✝ }.map (𝟙 X) = 𝟙 ({ obj := G_obj ∘ obj, map := map✝ }.obj X)
map_comp✝ :
  ∀ {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
    { obj := G_obj ∘ obj, map := map✝ }.map (f ≫ g) =
      { obj := G_obj ∘ obj, map := map✝ }.map f ≫ { obj := G_obj ∘ obj, map := map✝ }.map g
inst✝ : Faithful (Functor.mk { obj := G_obj ∘ obj, map := map✝ })
h_obj :
  ∀ (X : C),
    (Functor.mk { obj := G_obj, map := map✝¹ }).obj (obj X) = (Functor.mk { obj := G_obj ∘ obj, map := map✝ }).obj X
h_map :
  ∀ {X Y : C} {f : X ⟶ Y},
    HEq ((Functor.mk { obj := G_obj, map := map✝¹ }).map (map f))
      ((Functor.mk { obj := G_obj ∘ obj, map := map✝ }).map f)
⊢ (fun {X Y} f => (Functor.mk { obj := G_obj, map := map✝¹ }).map ((Functor.mk { obj := obj, map := map }).map f)) =
    map✝
[PROOFSTEP]
simp only [Function.comp_apply, heq_eq_eq] at h_map
[GOAL]
case mk.mk.mk.mk.e_toPrefunctor.e_map
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
F F' : C ⥤ D
G : D ⥤ E
obj : C → D
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
G_obj : D → E
map✝¹ : {X Y : D} → (X ⟶ Y) → (G_obj X ⟶ G_obj Y)
map_id✝¹ : ∀ (X : D), { obj := G_obj, map := map✝¹ }.map (𝟙 X) = 𝟙 ({ obj := G_obj, map := map✝¹ }.obj X)
map_comp✝¹ :
  ∀ {X Y Z : D} (f : X ⟶ Y) (g : Y ⟶ Z),
    { obj := G_obj, map := map✝¹ }.map (f ≫ g) =
      { obj := G_obj, map := map✝¹ }.map f ≫ { obj := G_obj, map := map✝¹ }.map g
inst✝¹ : Faithful (Functor.mk { obj := G_obj, map := map✝¹ })
map✝ : {X Y : C} → (X ⟶ Y) → ((G_obj ∘ obj) X ⟶ (G_obj ∘ obj) Y)
map_id✝ : ∀ (X : C), { obj := G_obj ∘ obj, map := map✝ }.map (𝟙 X) = 𝟙 ({ obj := G_obj ∘ obj, map := map✝ }.obj X)
map_comp✝ :
  ∀ {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
    { obj := G_obj ∘ obj, map := map✝ }.map (f ≫ g) =
      { obj := G_obj ∘ obj, map := map✝ }.map f ≫ { obj := G_obj ∘ obj, map := map✝ }.map g
inst✝ : Faithful (Functor.mk { obj := G_obj ∘ obj, map := map✝ })
h_obj :
  ∀ (X : C),
    (Functor.mk { obj := G_obj, map := map✝¹ }).obj (obj X) = (Functor.mk { obj := G_obj ∘ obj, map := map✝ }).obj X
h_map✝ :
  ∀ {X Y : C} {f : X ⟶ Y},
    HEq ((Functor.mk { obj := G_obj, map := map✝¹ }).map (map f))
      ((Functor.mk { obj := G_obj ∘ obj, map := map✝ }).map f)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, map✝¹ (map f) = map✝ f
⊢ (fun {X Y} f => (Functor.mk { obj := G_obj, map := map✝¹ }).map ((Functor.mk { obj := obj, map := map }).map f)) =
    map✝
[PROOFSTEP]
ext
[GOAL]
case mk.mk.mk.mk.e_toPrefunctor.e_map.h.h.h
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
F F' : C ⥤ D
G : D ⥤ E
obj : C → D
map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)
G_obj : D → E
map✝¹ : {X Y : D} → (X ⟶ Y) → (G_obj X ⟶ G_obj Y)
map_id✝¹ : ∀ (X : D), { obj := G_obj, map := map✝¹ }.map (𝟙 X) = 𝟙 ({ obj := G_obj, map := map✝¹ }.obj X)
map_comp✝¹ :
  ∀ {X Y Z : D} (f : X ⟶ Y) (g : Y ⟶ Z),
    { obj := G_obj, map := map✝¹ }.map (f ≫ g) =
      { obj := G_obj, map := map✝¹ }.map f ≫ { obj := G_obj, map := map✝¹ }.map g
inst✝¹ : Faithful (Functor.mk { obj := G_obj, map := map✝¹ })
map✝ : {X Y : C} → (X ⟶ Y) → ((G_obj ∘ obj) X ⟶ (G_obj ∘ obj) Y)
map_id✝ : ∀ (X : C), { obj := G_obj ∘ obj, map := map✝ }.map (𝟙 X) = 𝟙 ({ obj := G_obj ∘ obj, map := map✝ }.obj X)
map_comp✝ :
  ∀ {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
    { obj := G_obj ∘ obj, map := map✝ }.map (f ≫ g) =
      { obj := G_obj ∘ obj, map := map✝ }.map f ≫ { obj := G_obj ∘ obj, map := map✝ }.map g
inst✝ : Faithful (Functor.mk { obj := G_obj ∘ obj, map := map✝ })
h_obj :
  ∀ (X : C),
    (Functor.mk { obj := G_obj, map := map✝¹ }).obj (obj X) = (Functor.mk { obj := G_obj ∘ obj, map := map✝ }).obj X
h_map✝ :
  ∀ {X Y : C} {f : X ⟶ Y},
    HEq ((Functor.mk { obj := G_obj, map := map✝¹ }).map (map f))
      ((Functor.mk { obj := G_obj ∘ obj, map := map✝ }).map f)
h_map : ∀ {X Y : C} {f : X ⟶ Y}, map✝¹ (map f) = map✝ f
x✝² x✝¹ : C
x✝ : x✝² ⟶ x✝¹
⊢ (Functor.mk { obj := G_obj, map := map✝¹ }).map ((Functor.mk { obj := obj, map := map }).map x✝) = map✝ x✝
[PROOFSTEP]
exact h_map
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
F✝ F' : C ⥤ D
G✝ : D ⥤ E
F G : C ⥤ D
H : D ⥤ E
inst✝¹ : Full H
inst✝ : Faithful H
comp_iso : F ⋙ H ≅ G ⋙ H
X✝ Y✝ : C
f : X✝ ⟶ Y✝
⊢ H.map (F.map f ≫ ((fun X => Functor.preimageIso H (comp_iso.app X)) Y✝).hom) =
    H.map (((fun X => Functor.preimageIso H (comp_iso.app X)) X✝).hom ≫ G.map f)
[PROOFSTEP]
simpa using comp_iso.hom.naturality f


[GOAL]
α : Type u_1
β : Type u_2
M✝ : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
R : Type u_9
M : Type u_10
inst✝² : Zero R
inst✝¹ : Zero M
inst✝ : ZeroHomClass F R M
f : F
r : R
neZero : NeZero (↑f r)
h : r = 0
⊢ ↑f r = 0
[PROOFSTEP]
rw [h]
[GOAL]
α : Type u_1
β : Type u_2
M✝ : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
R : Type u_9
M : Type u_10
inst✝² : Zero R
inst✝¹ : Zero M
inst✝ : ZeroHomClass F R M
f : F
r : R
neZero : NeZero (↑f r)
h : r = 0
⊢ ↑f 0 = 0
[PROOFSTEP]
exact ZeroHomClass.map_zero f
[GOAL]
α : Type u_1
β : Type u_2
M✝ : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
R : Type u_9
M : Type u_10
inst✝³ : Zero R
r : R
inst✝² : NeZero r
inst✝¹ : Zero M
inst✝ : ZeroHomClass F R M
f : F
hf : Function.Injective ↑f
⊢ ↑f r ≠ 0
[PROOFSTEP]
rw [← ZeroHomClass.map_zero f]
[GOAL]
α : Type u_1
β : Type u_2
M✝ : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
R : Type u_9
M : Type u_10
inst✝³ : Zero R
r : R
inst✝² : NeZero r
inst✝¹ : Zero M
inst✝ : ZeroHomClass F R M
f : F
hf : Function.Injective ↑f
⊢ ↑f r ≠ ↑f 0
[PROOFSTEP]
exact hf.ne NeZero.out
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝¹ : One M
inst✝ : One N
f g : OneHom M N
h : f.toFun = g.toFun
⊢ f = g
[PROOFSTEP]
cases f
[GOAL]
case mk
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝¹ : One M
inst✝ : One N
g : OneHom M N
toFun✝ : M → N
map_one'✝ : toFun✝ 1 = 1
h : { toFun := toFun✝, map_one' := map_one'✝ }.toFun = g.toFun
⊢ { toFun := toFun✝, map_one' := map_one'✝ } = g
[PROOFSTEP]
cases g
[GOAL]
case mk.mk
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝¹ : One M
inst✝ : One N
toFun✝¹ : M → N
map_one'✝¹ : toFun✝¹ 1 = 1
toFun✝ : M → N
map_one'✝ : toFun✝ 1 = 1
h : { toFun := toFun✝¹, map_one' := map_one'✝¹ }.toFun = { toFun := toFun✝, map_one' := map_one'✝ }.toFun
⊢ { toFun := toFun✝¹, map_one' := map_one'✝¹ } = { toFun := toFun✝, map_one' := map_one'✝ }
[PROOFSTEP]
congr
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝¹ : Mul M
inst✝ : Mul N
f g : M →ₙ* N
h : f.toFun = g.toFun
⊢ f = g
[PROOFSTEP]
cases f
[GOAL]
case mk
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝¹ : Mul M
inst✝ : Mul N
g : M →ₙ* N
toFun✝ : M → N
map_mul'✝ : ∀ (x y : M), toFun✝ (x * y) = toFun✝ x * toFun✝ y
h : { toFun := toFun✝, map_mul' := map_mul'✝ }.toFun = g.toFun
⊢ { toFun := toFun✝, map_mul' := map_mul'✝ } = g
[PROOFSTEP]
cases g
[GOAL]
case mk.mk
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝¹ : Mul M
inst✝ : Mul N
toFun✝¹ : M → N
map_mul'✝¹ : ∀ (x y : M), toFun✝¹ (x * y) = toFun✝¹ x * toFun✝¹ y
toFun✝ : M → N
map_mul'✝ : ∀ (x y : M), toFun✝ (x * y) = toFun✝ x * toFun✝ y
h : { toFun := toFun✝¹, map_mul' := map_mul'✝¹ }.toFun = { toFun := toFun✝, map_mul' := map_mul'✝ }.toFun
⊢ { toFun := toFun✝¹, map_mul' := map_mul'✝¹ } = { toFun := toFun✝, map_mul' := map_mul'✝ }
[PROOFSTEP]
congr
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝¹ : MulOneClass M
inst✝ : MulOneClass N
f g : M →* N
h : (fun f => f.toFun) f = (fun f => f.toFun) g
⊢ f = g
[PROOFSTEP]
cases f
[GOAL]
case mk
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝¹ : MulOneClass M
inst✝ : MulOneClass N
g : M →* N
toOneHom✝ : OneHom M N
map_mul'✝ : ∀ (x y : M), OneHom.toFun toOneHom✝ (x * y) = OneHom.toFun toOneHom✝ x * OneHom.toFun toOneHom✝ y
h : (fun f => f.toFun) { toOneHom := toOneHom✝, map_mul' := map_mul'✝ } = (fun f => f.toFun) g
⊢ { toOneHom := toOneHom✝, map_mul' := map_mul'✝ } = g
[PROOFSTEP]
cases g
[GOAL]
case mk.mk
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝¹ : MulOneClass M
inst✝ : MulOneClass N
toOneHom✝¹ : OneHom M N
map_mul'✝¹ : ∀ (x y : M), OneHom.toFun toOneHom✝¹ (x * y) = OneHom.toFun toOneHom✝¹ x * OneHom.toFun toOneHom✝¹ y
toOneHom✝ : OneHom M N
map_mul'✝ : ∀ (x y : M), OneHom.toFun toOneHom✝ (x * y) = OneHom.toFun toOneHom✝ x * OneHom.toFun toOneHom✝ y
h :
  (fun f => f.toFun) { toOneHom := toOneHom✝¹, map_mul' := map_mul'✝¹ } =
    (fun f => f.toFun) { toOneHom := toOneHom✝, map_mul' := map_mul'✝ }
⊢ { toOneHom := toOneHom✝¹, map_mul' := map_mul'✝¹ } = { toOneHom := toOneHom✝, map_mul' := map_mul'✝ }
[PROOFSTEP]
congr
[GOAL]
case mk.mk.e_toOneHom
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝¹ : MulOneClass M
inst✝ : MulOneClass N
toOneHom✝¹ : OneHom M N
map_mul'✝¹ : ∀ (x y : M), OneHom.toFun toOneHom✝¹ (x * y) = OneHom.toFun toOneHom✝¹ x * OneHom.toFun toOneHom✝¹ y
toOneHom✝ : OneHom M N
map_mul'✝ : ∀ (x y : M), OneHom.toFun toOneHom✝ (x * y) = OneHom.toFun toOneHom✝ x * OneHom.toFun toOneHom✝ y
h :
  (fun f => f.toFun) { toOneHom := toOneHom✝¹, map_mul' := map_mul'✝¹ } =
    (fun f => f.toFun) { toOneHom := toOneHom✝, map_mul' := map_mul'✝ }
⊢ toOneHom✝¹ = toOneHom✝
[PROOFSTEP]
apply FunLike.coe_injective'
[GOAL]
case mk.mk.e_toOneHom.a
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝¹ : MulOneClass M
inst✝ : MulOneClass N
toOneHom✝¹ : OneHom M N
map_mul'✝¹ : ∀ (x y : M), OneHom.toFun toOneHom✝¹ (x * y) = OneHom.toFun toOneHom✝¹ x * OneHom.toFun toOneHom✝¹ y
toOneHom✝ : OneHom M N
map_mul'✝ : ∀ (x y : M), OneHom.toFun toOneHom✝ (x * y) = OneHom.toFun toOneHom✝ x * OneHom.toFun toOneHom✝ y
h :
  (fun f => f.toFun) { toOneHom := toOneHom✝¹, map_mul' := map_mul'✝¹ } =
    (fun f => f.toFun) { toOneHom := toOneHom✝, map_mul' := map_mul'✝ }
⊢ ↑toOneHom✝¹ = ↑toOneHom✝
[PROOFSTEP]
exact h
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MonoidHomClass F M N
f : F
a b : M
h : a * b = 1
⊢ ↑f a * ↑f b = 1
[PROOFSTEP]
rw [← map_mul, h, map_one]
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : DivInvMonoid G
inst✝¹ : DivInvMonoid H
inst✝ : MonoidHomClass F G H
f : F
hf : ∀ (a : G), ↑f a⁻¹ = (↑f a)⁻¹
a b : G
⊢ ↑f (a / b) = ↑f a / ↑f b
[PROOFSTEP]
rw [div_eq_mul_inv, div_eq_mul_inv, map_mul, hf]
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : Group G
inst✝¹ : DivisionMonoid H
inst✝ : MonoidHomClass F G H
f : F
a b : G
⊢ ↑f (a * b⁻¹) = ↑f a * (↑f b)⁻¹
[PROOFSTEP]
rw [map_mul, map_inv]
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : Monoid G
inst✝¹ : Monoid H
inst✝ : MonoidHomClass F G H
f : F
a : G
⊢ ↑f (a ^ 0) = ↑f a ^ 0
[PROOFSTEP]
rw [pow_zero, pow_zero, map_one]
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : Monoid G
inst✝¹ : Monoid H
inst✝ : MonoidHomClass F G H
f : F
a : G
n : ℕ
⊢ ↑f (a ^ (n + 1)) = ↑f a ^ (n + 1)
[PROOFSTEP]
rw [pow_succ, pow_succ, map_mul, map_pow f a n]
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : DivInvMonoid G
inst✝¹ : DivInvMonoid H
inst✝ : MonoidHomClass F G H
f : F
hf : ∀ (x : G), ↑f x⁻¹ = (↑f x)⁻¹
a : G
n : ℕ
⊢ ↑f (a ^ ↑n) = ↑f a ^ ↑n
[PROOFSTEP]
rw [zpow_ofNat, map_pow, zpow_ofNat]
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : DivInvMonoid G
inst✝¹ : DivInvMonoid H
inst✝ : MonoidHomClass F G H
f : F
hf : ∀ (x : G), ↑f x⁻¹ = (↑f x)⁻¹
a : G
n : ℕ
⊢ ↑f (a ^ Int.negSucc n) = ↑f a ^ Int.negSucc n
[PROOFSTEP]
rw [zpow_negSucc, hf, map_pow, ← zpow_negSucc, ← zpow_negSucc]
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝¹ : MulZeroOneClass M
inst✝ : MulZeroOneClass N
f g : M →*₀ N
h : (fun f => f.toFun) f = (fun f => f.toFun) g
⊢ f = g
[PROOFSTEP]
cases f
[GOAL]
case mk
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝¹ : MulZeroOneClass M
inst✝ : MulZeroOneClass N
g : M →*₀ N
toZeroHom✝ : ZeroHom M N
map_one'✝ : ZeroHom.toFun toZeroHom✝ 1 = 1
map_mul'✝ : ∀ (x y : M), ZeroHom.toFun toZeroHom✝ (x * y) = ZeroHom.toFun toZeroHom✝ x * ZeroHom.toFun toZeroHom✝ y
h : (fun f => f.toFun) { toZeroHom := toZeroHom✝, map_one' := map_one'✝, map_mul' := map_mul'✝ } = (fun f => f.toFun) g
⊢ { toZeroHom := toZeroHom✝, map_one' := map_one'✝, map_mul' := map_mul'✝ } = g
[PROOFSTEP]
cases g
[GOAL]
case mk.mk
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝¹ : MulZeroOneClass M
inst✝ : MulZeroOneClass N
toZeroHom✝¹ : ZeroHom M N
map_one'✝¹ : ZeroHom.toFun toZeroHom✝¹ 1 = 1
map_mul'✝¹ : ∀ (x y : M), ZeroHom.toFun toZeroHom✝¹ (x * y) = ZeroHom.toFun toZeroHom✝¹ x * ZeroHom.toFun toZeroHom✝¹ y
toZeroHom✝ : ZeroHom M N
map_one'✝ : ZeroHom.toFun toZeroHom✝ 1 = 1
map_mul'✝ : ∀ (x y : M), ZeroHom.toFun toZeroHom✝ (x * y) = ZeroHom.toFun toZeroHom✝ x * ZeroHom.toFun toZeroHom✝ y
h :
  (fun f => f.toFun) { toZeroHom := toZeroHom✝¹, map_one' := map_one'✝¹, map_mul' := map_mul'✝¹ } =
    (fun f => f.toFun) { toZeroHom := toZeroHom✝, map_one' := map_one'✝, map_mul' := map_mul'✝ }
⊢ { toZeroHom := toZeroHom✝¹, map_one' := map_one'✝¹, map_mul' := map_mul'✝¹ } =
    { toZeroHom := toZeroHom✝, map_one' := map_one'✝, map_mul' := map_mul'✝ }
[PROOFSTEP]
congr
[GOAL]
case mk.mk.e_toZeroHom
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝¹ : MulZeroOneClass M
inst✝ : MulZeroOneClass N
toZeroHom✝¹ : ZeroHom M N
map_one'✝¹ : ZeroHom.toFun toZeroHom✝¹ 1 = 1
map_mul'✝¹ : ∀ (x y : M), ZeroHom.toFun toZeroHom✝¹ (x * y) = ZeroHom.toFun toZeroHom✝¹ x * ZeroHom.toFun toZeroHom✝¹ y
toZeroHom✝ : ZeroHom M N
map_one'✝ : ZeroHom.toFun toZeroHom✝ 1 = 1
map_mul'✝ : ∀ (x y : M), ZeroHom.toFun toZeroHom✝ (x * y) = ZeroHom.toFun toZeroHom✝ x * ZeroHom.toFun toZeroHom✝ y
h :
  (fun f => f.toFun) { toZeroHom := toZeroHom✝¹, map_one' := map_one'✝¹, map_mul' := map_mul'✝¹ } =
    (fun f => f.toFun) { toZeroHom := toZeroHom✝, map_one' := map_one'✝, map_mul' := map_mul'✝ }
⊢ toZeroHom✝¹ = toZeroHom✝
[PROOFSTEP]
apply FunLike.coe_injective'
[GOAL]
case mk.mk.e_toZeroHom.a
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝¹ : MulZeroOneClass M
inst✝ : MulZeroOneClass N
toZeroHom✝¹ : ZeroHom M N
map_one'✝¹ : ZeroHom.toFun toZeroHom✝¹ 1 = 1
map_mul'✝¹ : ∀ (x y : M), ZeroHom.toFun toZeroHom✝¹ (x * y) = ZeroHom.toFun toZeroHom✝¹ x * ZeroHom.toFun toZeroHom✝¹ y
toZeroHom✝ : ZeroHom M N
map_one'✝ : ZeroHom.toFun toZeroHom✝ 1 = 1
map_mul'✝ : ∀ (x y : M), ZeroHom.toFun toZeroHom✝ (x * y) = ZeroHom.toFun toZeroHom✝ x * ZeroHom.toFun toZeroHom✝ y
h :
  (fun f => f.toFun) { toZeroHom := toZeroHom✝¹, map_one' := map_one'✝¹, map_mul' := map_mul'✝¹ } =
    (fun f => f.toFun) { toZeroHom := toZeroHom✝, map_one' := map_one'✝, map_mul' := map_mul'✝ }
⊢ ↑toZeroHom✝¹ = ↑toZeroHom✝
[PROOFSTEP]
exact h
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
hnp : OneHom N P
hmn : OneHom M N
⊢ (↑hnp ∘ ↑hmn) 1 = 1
[PROOFSTEP]
simp
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
hnp : N →ₙ* P
hmn : M →ₙ* N
x y : M
⊢ (↑hnp ∘ ↑hmn) (x * y) = (↑hnp ∘ ↑hmn) x * (↑hnp ∘ ↑hmn) y
[PROOFSTEP]
simp
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
hnp : N →* P
hmn : M →* N
⊢ (↑hnp ∘ ↑hmn) 1 = 1
[PROOFSTEP]
simp
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
hnp : N →* P
hmn : M →* N
⊢ ∀ (x y : M),
    OneHom.toFun { toFun := ↑hnp ∘ ↑hmn, map_one' := (_ : ↑hnp (↑hmn 1) = 1) } (x * y) =
      OneHom.toFun { toFun := ↑hnp ∘ ↑hmn, map_one' := (_ : ↑hnp (↑hmn 1) = 1) } x *
        OneHom.toFun { toFun := ↑hnp ∘ ↑hmn, map_one' := (_ : ↑hnp (↑hmn 1) = 1) } y
[PROOFSTEP]
simp
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝² : MulZeroOneClass M
inst✝¹ : MulZeroOneClass N
inst✝ : MulZeroOneClass P
hnp : N →*₀ P
hmn : M →*₀ N
⊢ (↑hnp ∘ ↑hmn) 0 = 0
[PROOFSTEP]
rw [Function.comp_apply, map_zero, map_zero]
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝² : MulZeroOneClass M
inst✝¹ : MulZeroOneClass N
inst✝ : MulZeroOneClass P
hnp : N →*₀ P
hmn : M →*₀ N
⊢ ZeroHom.toFun { toFun := ↑hnp ∘ ↑hmn, map_zero' := (_ : (↑hnp ∘ ↑hmn) 0 = 0) } 1 = 1
[PROOFSTEP]
simp
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝² : MulZeroOneClass M
inst✝¹ : MulZeroOneClass N
inst✝ : MulZeroOneClass P
hnp : N →*₀ P
hmn : M →*₀ N
⊢ ∀ (x y : M),
    ZeroHom.toFun { toFun := ↑hnp ∘ ↑hmn, map_zero' := (_ : (↑hnp ∘ ↑hmn) 0 = 0) } (x * y) =
      ZeroHom.toFun { toFun := ↑hnp ∘ ↑hmn, map_zero' := (_ : (↑hnp ∘ ↑hmn) 0 = 0) } x *
        ZeroHom.toFun { toFun := ↑hnp ∘ ↑hmn, map_zero' := (_ : (↑hnp ∘ ↑hmn) 0 = 0) } y
[PROOFSTEP]
simp
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
g : OneHom N P
f₁ f₂ : OneHom M N
hg : Function.Injective ↑g
h : comp g f₁ = comp g f₂
x : M
⊢ ↑g (↑f₁ x) = ↑g (↑f₂ x)
[PROOFSTEP]
rw [← OneHom.comp_apply, h, OneHom.comp_apply]
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
g : N →ₙ* P
f₁ f₂ : M →ₙ* N
hg : Function.Injective ↑g
h : comp g f₁ = comp g f₂
x : M
⊢ ↑g (↑f₁ x) = ↑g (↑f₂ x)
[PROOFSTEP]
rw [← MulHom.comp_apply, h, MulHom.comp_apply]
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
g : N →* P
f₁ f₂ : M →* N
hg : Function.Injective ↑g
h : comp g f₁ = comp g f₂
x : M
⊢ ↑g (↑f₁ x) = ↑g (↑f₂ x)
[PROOFSTEP]
rw [← MonoidHom.comp_apply, h, MonoidHom.comp_apply]
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝² : MulZeroOneClass M
inst✝¹ : MulZeroOneClass N
inst✝ : MulZeroOneClass P
g : N →*₀ P
f₁ f₂ : M →*₀ N
hg : Function.Injective ↑g
h : comp g f₁ = comp g f₂
x : M
⊢ ↑g (↑f₁ x) = ↑g (↑f₂ x)
[PROOFSTEP]
rw [← MonoidWithZeroHom.comp_apply, h, MonoidWithZeroHom.comp_apply]
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
f : OneHom N P
⊢ comp f 1 = 1
[PROOFSTEP]
ext
[GOAL]
case h
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
f : OneHom N P
x✝ : M
⊢ ↑(comp f 1) x✝ = ↑1 x✝
[PROOFSTEP]
simp only [OneHom.map_one, OneHom.coe_comp, Function.comp_apply, OneHom.one_apply]
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝¹ : Mul M
inst✝ : CommSemigroup N
f g : M →ₙ* N
x y : M
⊢ (fun m => ↑f m * ↑g m) (x * y) = (fun m => ↑f m * ↑g m) x * (fun m => ↑f m * ↑g m) y
[PROOFSTEP]
intros
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝¹ : Mul M
inst✝ : CommSemigroup N
f g : M →ₙ* N
x y : M
⊢ (fun m => ↑f m * ↑g m) (x * y) = (fun m => ↑f m * ↑g m) x * (fun m => ↑f m * ↑g m) y
[PROOFSTEP]
show f (x * y) * g (x * y) = f x * g x * (f y * g y)
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝¹ : Mul M
inst✝ : CommSemigroup N
f g : M →ₙ* N
x y : M
⊢ ↑f (x * y) * ↑g (x * y) = ↑f x * ↑g x * (↑f y * ↑g y)
[PROOFSTEP]
rw [f.map_mul, g.map_mul, ← mul_assoc, ← mul_assoc, mul_right_comm (f x)]
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝² : Mul M
inst✝¹ : CommSemigroup N
inst✝ : CommSemigroup P
g : N →ₙ* P
f₁ f₂ : M →ₙ* N
⊢ comp g (f₁ * f₂) = comp g f₁ * comp g f₂
[PROOFSTEP]
ext
[GOAL]
case h
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝² : Mul M
inst✝¹ : CommSemigroup N
inst✝ : CommSemigroup P
g : N →ₙ* P
f₁ f₂ : M →ₙ* N
x✝ : M
⊢ ↑(comp g (f₁ * f₂)) x✝ = ↑(comp g f₁ * comp g f₂) x✝
[PROOFSTEP]
simp only [mul_apply, Function.comp_apply, map_mul, coe_comp]
[GOAL]
α : Type u_1
β : Type u_2
M✝ : Type u_3
N✝ : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝³ : Group G
inst✝² : CommGroup H
M : Type ?u.198672
N : Type ?u.198675
inst✝¹ : MulOneClass M
inst✝ : CommMonoid N
f g : M →* N
⊢ ↑f 1 * ↑g 1 = 1
[PROOFSTEP]
simp
[GOAL]
α : Type u_1
β : Type u_2
M✝ : Type u_3
N✝ : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝³ : Group G
inst✝² : CommGroup H
M : Type ?u.198672
N : Type ?u.198675
inst✝¹ : MulOneClass M
inst✝ : CommMonoid N
f g : M →* N
x y : M
⊢ OneHom.toFun { toFun := fun m => ↑f m * ↑g m, map_one' := (_ : ↑f 1 * ↑g 1 = 1) } (x * y) =
    OneHom.toFun { toFun := fun m => ↑f m * ↑g m, map_one' := (_ : ↑f 1 * ↑g 1 = 1) } x *
      OneHom.toFun { toFun := fun m => ↑f m * ↑g m, map_one' := (_ : ↑f 1 * ↑g 1 = 1) } y
[PROOFSTEP]
intros
[GOAL]
α : Type u_1
β : Type u_2
M✝ : Type u_3
N✝ : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝³ : Group G
inst✝² : CommGroup H
M : Type ?u.198672
N : Type ?u.198675
inst✝¹ : MulOneClass M
inst✝ : CommMonoid N
f g : M →* N
x y : M
⊢ OneHom.toFun { toFun := fun m => ↑f m * ↑g m, map_one' := (_ : ↑f 1 * ↑g 1 = 1) } (x * y) =
    OneHom.toFun { toFun := fun m => ↑f m * ↑g m, map_one' := (_ : ↑f 1 * ↑g 1 = 1) } x *
      OneHom.toFun { toFun := fun m => ↑f m * ↑g m, map_one' := (_ : ↑f 1 * ↑g 1 = 1) } y
[PROOFSTEP]
show f (x * y) * g (x * y) = f x * g x * (f y * g y)
[GOAL]
α : Type u_1
β : Type u_2
M✝ : Type u_3
N✝ : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝³ : Group G
inst✝² : CommGroup H
M : Type ?u.198672
N : Type ?u.198675
inst✝¹ : MulOneClass M
inst✝ : CommMonoid N
f g : M →* N
x y : M
⊢ ↑f (x * y) * ↑g (x * y) = ↑f x * ↑g x * (↑f y * ↑g y)
[PROOFSTEP]
rw [f.map_mul, g.map_mul, ← mul_assoc, ← mul_assoc, mul_right_comm (f x)]
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝⁴ : Group G
inst✝³ : CommGroup H
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
f : N →* P
⊢ comp f 1 = 1
[PROOFSTEP]
ext
[GOAL]
case h
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝⁴ : Group G
inst✝³ : CommGroup H
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
f : N →* P
x✝ : M
⊢ ↑(comp f 1) x✝ = ↑1 x✝
[PROOFSTEP]
simp only [map_one, coe_comp, Function.comp_apply, one_apply]
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝⁴ : Group G
inst✝³ : CommGroup H
inst✝² : MulOneClass M
inst✝¹ : CommMonoid N
inst✝ : CommMonoid P
g : N →* P
f₁ f₂ : M →* N
⊢ comp g (f₁ * f₂) = comp g f₁ * comp g f₂
[PROOFSTEP]
ext
[GOAL]
case h
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝⁴ : Group G
inst✝³ : CommGroup H
inst✝² : MulOneClass M
inst✝¹ : CommMonoid N
inst✝ : CommMonoid P
g : N →* P
f₁ f₂ : M →* N
x✝ : M
⊢ ↑(comp g (f₁ * f₂)) x✝ = ↑(comp g f₁ * comp g f₂) x✝
[PROOFSTEP]
simp only [mul_apply, Function.comp_apply, map_mul, coe_comp]
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝³ : Group G
inst✝² : CommGroup H
inst✝¹ : Group α
inst✝ : DivisionMonoid β
f : α →* β
g h : α
⊢ ↑f (g * h⁻¹) = ↑f g * (↑f h)⁻¹
[PROOFSTEP]
simp
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G✝ : Type u_6
H✝ : Type u_7
F : Type u_8
inst✝⁴ : Group G✝
inst✝³ : CommGroup H✝
G : Type u_9
H : Type u_10
inst✝² : Group G
inst✝¹ : MulOneClass H
inst✝ : MonoidHomClass F G H
f : F
h : ∀ (a : G), ↑f a = 1 → a = 1
x y : G
hxy : ↑f x = ↑f y
⊢ ↑f (x * y⁻¹) = 1
[PROOFSTEP]
rw [map_mul, hxy, ← map_mul, mul_inv_self, map_one]
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝² : Group G
inst✝¹ : CommGroup H
inst✝ : MulOneClass M
f : M → G
map_mul : ∀ (a b : M), f (a * b) = f a * f b
⊢ f 1 * ?m.224335 f map_mul = ?m.224335 f map_mul
[PROOFSTEP]
rw [← map_mul, mul_one]
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H✝ : Type u_7
F : Type u_8
inst✝³ : Group G
inst✝² : CommGroup H✝
inst✝¹ : MulOneClass M
H : Type u_9
inst✝ : Group H
f : G → H
map_div : ∀ (a b : G), f (a * b⁻¹) = f a * (f b)⁻¹
x y : G
⊢ f (x * y) = f x * (f (1 * 1⁻¹ * y⁻¹))⁻¹
[PROOFSTEP]
{simp only [one_mul, inv_one, ← map_div, inv_inv]
}
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H✝ : Type u_7
F : Type u_8
inst✝³ : Group G
inst✝² : CommGroup H✝
inst✝¹ : MulOneClass M
H : Type u_9
inst✝ : Group H
f : G → H
map_div : ∀ (a b : G), f (a * b⁻¹) = f a * (f b)⁻¹
x y : G
⊢ f (x * y) = f x * (f (1 * 1⁻¹ * y⁻¹))⁻¹
[PROOFSTEP]
simp only [one_mul, inv_one, ← map_div, inv_inv]
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H✝ : Type u_7
F : Type u_8
inst✝³ : Group G
inst✝² : CommGroup H✝
inst✝¹ : MulOneClass M
H : Type u_9
inst✝ : Group H
f : G → H
map_div : ∀ (a b : G), f (a * b⁻¹) = f a * (f b)⁻¹
x y : G
⊢ f x * (f (1 * 1⁻¹ * y⁻¹))⁻¹ = f x * f y
[PROOFSTEP]
{ simp only [map_div]
  simp only [mul_right_inv, one_mul, inv_inv]
}
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H✝ : Type u_7
F : Type u_8
inst✝³ : Group G
inst✝² : CommGroup H✝
inst✝¹ : MulOneClass M
H : Type u_9
inst✝ : Group H
f : G → H
map_div : ∀ (a b : G), f (a * b⁻¹) = f a * (f b)⁻¹
x y : G
⊢ f x * (f (1 * 1⁻¹ * y⁻¹))⁻¹ = f x * f y
[PROOFSTEP]
simp only [map_div]
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H✝ : Type u_7
F : Type u_8
inst✝³ : Group G
inst✝² : CommGroup H✝
inst✝¹ : MulOneClass M
H : Type u_9
inst✝ : Group H
f : G → H
map_div : ∀ (a b : G), f (a * b⁻¹) = f a * (f b)⁻¹
x y : G
⊢ f x * (f 1 * (f 1)⁻¹ * (f y)⁻¹)⁻¹ = f x * f y
[PROOFSTEP]
simp only [mul_right_inv, one_mul, inv_inv]
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H✝ : Type u_7
F : Type u_8
inst✝³ : Group G
inst✝² : CommGroup H✝
inst✝¹ : MulOneClass M
H : Type u_9
inst✝ : Group H
f : G → H
hf : ∀ (x y : G), f (x / y) = f x / f y
⊢ ∀ (a b : G), f (a * b⁻¹) = f a * (f b)⁻¹
[PROOFSTEP]
simpa only [div_eq_mul_inv] using hf
[GOAL]
α : Type u_1
β : Type u_2
M✝ : Type u_3
N : Type u_4
P : Type u_5
G✝ : Type u_6
H : Type u_7
F : Type u_8
inst✝⁴ : Group G✝
inst✝³ : CommGroup H
inst✝² : MulOneClass M✝
M : Type ?u.229390
G : Type ?u.229393
inst✝¹ : MulOneClass M
inst✝ : CommGroup G
f : M →* G
a b : M
⊢ (↑f (a * b))⁻¹ = (↑f a)⁻¹ * (↑f b)⁻¹
[PROOFSTEP]
rw [← mul_inv, f.map_mul]
[GOAL]
α : Type u_1
β : Type u_2
M✝ : Type u_3
N✝ : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝⁵ : Group G
inst✝⁴ : CommGroup H
inst✝³ : MulOneClass M✝
M : Type u_9
N : Type u_10
A : Type u_11
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : CommGroup A
φ : N →* A
ψ : M →* N
⊢ comp φ⁻¹ ψ = (comp φ ψ)⁻¹
[PROOFSTEP]
ext
[GOAL]
case h
α : Type u_1
β : Type u_2
M✝ : Type u_3
N✝ : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝⁵ : Group G
inst✝⁴ : CommGroup H
inst✝³ : MulOneClass M✝
M : Type u_9
N : Type u_10
A : Type u_11
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : CommGroup A
φ : N →* A
ψ : M →* N
x✝ : M
⊢ ↑(comp φ⁻¹ ψ) x✝ = ↑(comp φ ψ)⁻¹ x✝
[PROOFSTEP]
simp only [Function.comp_apply, inv_apply, coe_comp]
[GOAL]
α : Type u_1
β : Type u_2
M✝ : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝⁵ : Group G
inst✝⁴ : CommGroup H
inst✝³ : MulOneClass M✝
M : Type u_9
A : Type u_10
B : Type u_11
inst✝² : MulOneClass M
inst✝¹ : CommGroup A
inst✝ : CommGroup B
φ : A →* B
ψ : M →* A
⊢ comp φ ψ⁻¹ = (comp φ ψ)⁻¹
[PROOFSTEP]
ext
[GOAL]
case h
α : Type u_1
β : Type u_2
M✝ : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝⁵ : Group G
inst✝⁴ : CommGroup H
inst✝³ : MulOneClass M✝
M : Type u_9
A : Type u_10
B : Type u_11
inst✝² : MulOneClass M
inst✝¹ : CommGroup A
inst✝ : CommGroup B
φ : A →* B
ψ : M →* A
x✝ : M
⊢ ↑(comp φ ψ⁻¹) x✝ = ↑(comp φ ψ)⁻¹ x✝
[PROOFSTEP]
simp only [Function.comp_apply, inv_apply, map_inv, coe_comp]
[GOAL]
α : Type u_1
β : Type u_2
M✝ : Type u_3
N : Type u_4
P : Type u_5
G✝ : Type u_6
H : Type u_7
F : Type u_8
inst✝⁴ : Group G✝
inst✝³ : CommGroup H
inst✝² : MulOneClass M✝
M : Type ?u.233732
G : Type ?u.233735
inst✝¹ : MulOneClass M
inst✝ : CommGroup G
f g : M →* G
a b : M
⊢ ↑f (a * b) / ↑g (a * b) = ↑f a / ↑g a * (↑f b / ↑g b)
[PROOFSTEP]
simp [div_eq_mul_inv, mul_assoc, mul_left_comm, mul_comm]
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝¹ : MulZeroOneClass M
inst✝ : CommMonoidWithZero N
f g : M →*₀ N
src✝ : M →* N := ↑f * ↑g
⊢ (fun a => ↑f a * ↑g a) 0 = 0
[PROOFSTEP]
dsimp only []
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝¹ : MulZeroOneClass M
inst✝ : CommMonoidWithZero N
f g : M →*₀ N
src✝ : M →* N := ↑f * ↑g
⊢ ↑f 0 * ↑g 0 = 0
[PROOFSTEP]
rw [map_zero, zero_mul]


[GOAL]
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
⊢ radius p = liminf (fun n => 1 / ↑(‖p n‖₊ ^ (1 / ↑n))) atTop
[PROOFSTEP]
have : ∀ (r : ℝ≥0) {n : ℕ}, 0 < n → ((r : ℝ≥0∞) ≤ 1 / ↑(‖p n‖₊ ^ (1 / (n : ℝ))) ↔ ‖p n‖₊ * r ^ n ≤ 1) :=
  by
  intro r n hn
  have : 0 < (n : ℝ) := Nat.cast_pos.2 hn
  conv_lhs =>
    rw [one_div, ENNReal.le_inv_iff_mul_le, ← ENNReal.coe_mul, ENNReal.coe_le_one_iff, one_div, ← NNReal.rpow_one r, ←
      mul_inv_cancel this.ne', NNReal.rpow_mul, ← NNReal.mul_rpow, ← NNReal.one_rpow n⁻¹,
      NNReal.rpow_le_rpow_iff (inv_pos.2 this), mul_comm, NNReal.rpow_nat_cast]
[GOAL]
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
⊢ ∀ (r : ℝ≥0) {n : ℕ}, 0 < n → (↑r ≤ 1 / ↑(‖p n‖₊ ^ (1 / ↑n)) ↔ ‖p n‖₊ * r ^ n ≤ 1)
[PROOFSTEP]
intro r n hn
[GOAL]
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
n : ℕ
hn : 0 < n
⊢ ↑r ≤ 1 / ↑(‖p n‖₊ ^ (1 / ↑n)) ↔ ‖p n‖₊ * r ^ n ≤ 1
[PROOFSTEP]
have : 0 < (n : ℝ) := Nat.cast_pos.2 hn
[GOAL]
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
n : ℕ
hn : 0 < n
this : 0 < ↑n
⊢ ↑r ≤ 1 / ↑(‖p n‖₊ ^ (1 / ↑n)) ↔ ‖p n‖₊ * r ^ n ≤ 1
[PROOFSTEP]
conv_lhs =>
  rw [one_div, ENNReal.le_inv_iff_mul_le, ← ENNReal.coe_mul, ENNReal.coe_le_one_iff, one_div, ← NNReal.rpow_one r, ←
    mul_inv_cancel this.ne', NNReal.rpow_mul, ← NNReal.mul_rpow, ← NNReal.one_rpow n⁻¹,
    NNReal.rpow_le_rpow_iff (inv_pos.2 this), mul_comm, NNReal.rpow_nat_cast]
[GOAL]
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
n : ℕ
hn : 0 < n
this : 0 < ↑n
| ↑r ≤ 1 / ↑(‖p n‖₊ ^ (1 / ↑n))
[PROOFSTEP]
rw [one_div, ENNReal.le_inv_iff_mul_le, ← ENNReal.coe_mul, ENNReal.coe_le_one_iff, one_div, ← NNReal.rpow_one r, ←
    mul_inv_cancel this.ne', NNReal.rpow_mul, ← NNReal.mul_rpow, ← NNReal.one_rpow n⁻¹,
    NNReal.rpow_le_rpow_iff (inv_pos.2 this), mul_comm, NNReal.rpow_nat_cast]
[GOAL]
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
n : ℕ
hn : 0 < n
this : 0 < ↑n
| ↑r ≤ 1 / ↑(‖p n‖₊ ^ (1 / ↑n))
[PROOFSTEP]
rw [one_div, ENNReal.le_inv_iff_mul_le, ← ENNReal.coe_mul, ENNReal.coe_le_one_iff, one_div, ← NNReal.rpow_one r, ←
    mul_inv_cancel this.ne', NNReal.rpow_mul, ← NNReal.mul_rpow, ← NNReal.one_rpow n⁻¹,
    NNReal.rpow_le_rpow_iff (inv_pos.2 this), mul_comm, NNReal.rpow_nat_cast]
[GOAL]
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
n : ℕ
hn : 0 < n
this : 0 < ↑n
| ↑r ≤ 1 / ↑(‖p n‖₊ ^ (1 / ↑n))
[PROOFSTEP]
rw [one_div, ENNReal.le_inv_iff_mul_le, ← ENNReal.coe_mul, ENNReal.coe_le_one_iff, one_div, ← NNReal.rpow_one r, ←
  mul_inv_cancel this.ne', NNReal.rpow_mul, ← NNReal.mul_rpow, ← NNReal.one_rpow n⁻¹,
  NNReal.rpow_le_rpow_iff (inv_pos.2 this), mul_comm, NNReal.rpow_nat_cast]
[GOAL]
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
this : ∀ (r : ℝ≥0) {n : ℕ}, 0 < n → (↑r ≤ 1 / ↑(‖p n‖₊ ^ (1 / ↑n)) ↔ ‖p n‖₊ * r ^ n ≤ 1)
⊢ radius p = liminf (fun n => 1 / ↑(‖p n‖₊ ^ (1 / ↑n))) atTop
[PROOFSTEP]
apply le_antisymm
[GOAL]
case a
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
this : ∀ (r : ℝ≥0) {n : ℕ}, 0 < n → (↑r ≤ 1 / ↑(‖p n‖₊ ^ (1 / ↑n)) ↔ ‖p n‖₊ * r ^ n ≤ 1)
⊢ radius p ≤ liminf (fun n => 1 / ↑(‖p n‖₊ ^ (1 / ↑n))) atTop
[PROOFSTEP]
refine' ENNReal.le_of_forall_nnreal_lt fun r hr => _
[GOAL]
case a
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
this : ∀ (r : ℝ≥0) {n : ℕ}, 0 < n → (↑r ≤ 1 / ↑(‖p n‖₊ ^ (1 / ↑n)) ↔ ‖p n‖₊ * r ^ n ≤ 1)
⊢ liminf (fun n => 1 / ↑(‖p n‖₊ ^ (1 / ↑n))) atTop ≤ radius p
[PROOFSTEP]
refine' ENNReal.le_of_forall_nnreal_lt fun r hr => _
[GOAL]
case a
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
this : ∀ (r : ℝ≥0) {n : ℕ}, 0 < n → (↑r ≤ 1 / ↑(‖p n‖₊ ^ (1 / ↑n)) ↔ ‖p n‖₊ * r ^ n ≤ 1)
r : ℝ≥0
hr : ↑r < radius p
⊢ ↑r ≤ liminf (fun n => 1 / ↑(‖p n‖₊ ^ (1 / ↑n))) atTop
[PROOFSTEP]
have := ((TFAE_exists_lt_isLittleO_pow (fun n => ‖p n‖ * r ^ n) 1).out 1 7).1 (p.isLittleO_of_lt_radius hr)
[GOAL]
case a
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
this✝ : ∀ (r : ℝ≥0) {n : ℕ}, 0 < n → (↑r ≤ 1 / ↑(‖p n‖₊ ^ (1 / ↑n)) ↔ ‖p n‖₊ * r ^ n ≤ 1)
r : ℝ≥0
hr : ↑r < radius p
this : ∃ a, a ∈ Set.Ioo 0 1 ∧ ∀ᶠ (n : ℕ) in atTop, |‖p n‖ * ↑(r ^ n)| ≤ a ^ n
⊢ ↑r ≤ liminf (fun n => 1 / ↑(‖p n‖₊ ^ (1 / ↑n))) atTop
[PROOFSTEP]
obtain ⟨a, ha, H⟩ := this
[GOAL]
case a.intro.intro
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
this : ∀ (r : ℝ≥0) {n : ℕ}, 0 < n → (↑r ≤ 1 / ↑(‖p n‖₊ ^ (1 / ↑n)) ↔ ‖p n‖₊ * r ^ n ≤ 1)
r : ℝ≥0
hr : ↑r < radius p
a : ℝ
ha : a ∈ Set.Ioo 0 1
H : ∀ᶠ (n : ℕ) in atTop, |‖p n‖ * ↑(r ^ n)| ≤ a ^ n
⊢ ↑r ≤ liminf (fun n => 1 / ↑(‖p n‖₊ ^ (1 / ↑n))) atTop
[PROOFSTEP]
apply le_liminf_of_le
[GOAL]
case a.intro.intro.hf
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
this : ∀ (r : ℝ≥0) {n : ℕ}, 0 < n → (↑r ≤ 1 / ↑(‖p n‖₊ ^ (1 / ↑n)) ↔ ‖p n‖₊ * r ^ n ≤ 1)
r : ℝ≥0
hr : ↑r < radius p
a : ℝ
ha : a ∈ Set.Ioo 0 1
H : ∀ᶠ (n : ℕ) in atTop, |‖p n‖ * ↑(r ^ n)| ≤ a ^ n
⊢ autoParam (IsCoboundedUnder (fun x x_1 => x ≥ x_1) atTop fun n => 1 / ↑(‖p n‖₊ ^ (1 / ↑n))) _auto✝
[PROOFSTEP]
infer_param
[GOAL]
case a.intro.intro.h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
this : ∀ (r : ℝ≥0) {n : ℕ}, 0 < n → (↑r ≤ 1 / ↑(‖p n‖₊ ^ (1 / ↑n)) ↔ ‖p n‖₊ * r ^ n ≤ 1)
r : ℝ≥0
hr : ↑r < radius p
a : ℝ
ha : a ∈ Set.Ioo 0 1
H : ∀ᶠ (n : ℕ) in atTop, |‖p n‖ * ↑(r ^ n)| ≤ a ^ n
⊢ ∀ᶠ (n : ℕ) in atTop, ↑r ≤ 1 / ↑(‖p n‖₊ ^ (1 / ↑n))
[PROOFSTEP]
rw [← eventually_map]
[GOAL]
case a.intro.intro.h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
this : ∀ (r : ℝ≥0) {n : ℕ}, 0 < n → (↑r ≤ 1 / ↑(‖p n‖₊ ^ (1 / ↑n)) ↔ ‖p n‖₊ * r ^ n ≤ 1)
r : ℝ≥0
hr : ↑r < radius p
a : ℝ
ha : a ∈ Set.Ioo 0 1
H : ∀ᶠ (n : ℕ) in atTop, |‖p n‖ * ↑(r ^ n)| ≤ a ^ n
⊢ ∀ᶠ (b : ℝ≥0∞) in map (fun n => 1 / ↑(‖p n‖₊ ^ (1 / ↑n))) atTop, ↑r ≤ b
[PROOFSTEP]
refine' H.mp ((eventually_gt_atTop 0).mono fun n hn₀ hn => (this _ hn₀).2 (NNReal.coe_le_coe.1 _))
[GOAL]
case a.intro.intro.h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
this : ∀ (r : ℝ≥0) {n : ℕ}, 0 < n → (↑r ≤ 1 / ↑(‖p n‖₊ ^ (1 / ↑n)) ↔ ‖p n‖₊ * r ^ n ≤ 1)
r : ℝ≥0
hr : ↑r < radius p
a : ℝ
ha : a ∈ Set.Ioo 0 1
H : ∀ᶠ (n : ℕ) in atTop, |‖p n‖ * ↑(r ^ n)| ≤ a ^ n
n : ℕ
hn₀ : 0 < n
hn : |‖p n‖ * ↑(r ^ n)| ≤ a ^ n
⊢ ↑(‖p n‖₊ * r ^ n) ≤ ↑1
[PROOFSTEP]
push_cast
[GOAL]
case a.intro.intro.h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
this : ∀ (r : ℝ≥0) {n : ℕ}, 0 < n → (↑r ≤ 1 / ↑(‖p n‖₊ ^ (1 / ↑n)) ↔ ‖p n‖₊ * r ^ n ≤ 1)
r : ℝ≥0
hr : ↑r < radius p
a : ℝ
ha : a ∈ Set.Ioo 0 1
H : ∀ᶠ (n : ℕ) in atTop, |‖p n‖ * ↑(r ^ n)| ≤ a ^ n
n : ℕ
hn₀ : 0 < n
hn : |‖p n‖ * ↑(r ^ n)| ≤ a ^ n
⊢ ‖p n‖ * ↑r ^ n ≤ 1
[PROOFSTEP]
exact (le_abs_self _).trans (hn.trans (pow_le_one _ ha.1.le ha.2.le))
[GOAL]
case a
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
this : ∀ (r : ℝ≥0) {n : ℕ}, 0 < n → (↑r ≤ 1 / ↑(‖p n‖₊ ^ (1 / ↑n)) ↔ ‖p n‖₊ * r ^ n ≤ 1)
r : ℝ≥0
hr : ↑r < liminf (fun n => 1 / ↑(‖p n‖₊ ^ (1 / ↑n))) atTop
⊢ ↑r ≤ radius p
[PROOFSTEP]
refine' p.le_radius_of_isBigO (IsBigO.of_bound 1 _)
[GOAL]
case a
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
this : ∀ (r : ℝ≥0) {n : ℕ}, 0 < n → (↑r ≤ 1 / ↑(‖p n‖₊ ^ (1 / ↑n)) ↔ ‖p n‖₊ * r ^ n ≤ 1)
r : ℝ≥0
hr : ↑r < liminf (fun n => 1 / ↑(‖p n‖₊ ^ (1 / ↑n))) atTop
⊢ ∀ᶠ (x : ℕ) in atTop, ‖‖p x‖ * ↑r ^ x‖ ≤ 1 * ‖1‖
[PROOFSTEP]
refine' (eventually_lt_of_lt_liminf hr).mp ((eventually_gt_atTop 0).mono fun n hn₀ hn => _)
[GOAL]
case a
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
this : ∀ (r : ℝ≥0) {n : ℕ}, 0 < n → (↑r ≤ 1 / ↑(‖p n‖₊ ^ (1 / ↑n)) ↔ ‖p n‖₊ * r ^ n ≤ 1)
r : ℝ≥0
hr : ↑r < liminf (fun n => 1 / ↑(‖p n‖₊ ^ (1 / ↑n))) atTop
n : ℕ
hn₀ : 0 < n
hn : ↑r < 1 / ↑(‖p n‖₊ ^ (1 / ↑n))
⊢ ‖‖p n‖ * ↑r ^ n‖ ≤ 1 * ‖1‖
[PROOFSTEP]
simpa using NNReal.coe_le_coe.2 ((this _ hn₀).1 hn.le)


[GOAL]
A : Type u_1
K : Type u_2
inst✝³ : CommRing A
S : Submonoid A
hS✝ : S ≤ A⁰
inst✝² : CommRing K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
hS : S ≤ A⁰
s : { x // x ∈ S }
⊢ IsUnit (↑(algebraMap A K) ↑s)
[PROOFSTEP]
apply IsLocalization.map_units K (⟨s.1, hS s.2⟩ : A⁰)
[GOAL]
A : Type u_1
K : Type u_2
inst✝⁶ : CommRing A
S : Submonoid A
hS✝ : S ≤ A⁰
inst✝⁵ : CommRing K
inst✝⁴ : Algebra A K
inst✝³ : IsFractionRing A K
B : Type u_3
inst✝² : CommRing B
inst✝¹ : Algebra A B
inst✝ : IsLocalization S B
hS : S ≤ A⁰
src✝ : B →+* K := IsLocalization.lift (_ : ∀ (s : { x // x ∈ S }), IsUnit (↑(algebraMap A K) ↑s))
a : A
⊢ OneHom.toFun
      (↑↑{ toMonoidHom := ↑src✝, map_zero' := (_ : OneHom.toFun (↑↑src✝) 0 = 0),
            map_add' :=
              (_ : ∀ (x y : B), OneHom.toFun (↑↑src✝) (x + y) = OneHom.toFun (↑↑src✝) x + OneHom.toFun (↑↑src✝) y) })
      (↑(algebraMap A B) a) =
    ↑(algebraMap A K) a
[PROOFSTEP]
simp
[GOAL]
A : Type u_1
K : Type u_2
inst✝⁶ : CommRing A
S : Submonoid A
hS✝ : S ≤ A⁰
inst✝⁵ : CommRing K
inst✝⁴ : Algebra A K
inst✝³ : IsFractionRing A K
B : Type u_3
inst✝² : CommRing B
inst✝¹ : Algebra A B
inst✝ : IsLocalization S B
hS : S ≤ A⁰
x : K
⊢ x ∈ AlgHom.range (mapToFractionRing K S B hS) →
    ∃ a s hs, x = IsLocalization.mk' K a { val := s, property := (_ : s ∈ A⁰) }
[PROOFSTEP]
rintro ⟨x, rfl⟩
[GOAL]
case intro
A : Type u_1
K : Type u_2
inst✝⁶ : CommRing A
S : Submonoid A
hS✝ : S ≤ A⁰
inst✝⁵ : CommRing K
inst✝⁴ : Algebra A K
inst✝³ : IsFractionRing A K
B : Type u_3
inst✝² : CommRing B
inst✝¹ : Algebra A B
inst✝ : IsLocalization S B
hS : S ≤ A⁰
x : B
⊢ ∃ a s hs, ↑↑(mapToFractionRing K S B hS) x = IsLocalization.mk' K a { val := s, property := (_ : s ∈ A⁰) }
[PROOFSTEP]
obtain ⟨a, s, rfl⟩ := IsLocalization.mk'_surjective S x
[GOAL]
case intro.intro.intro
A : Type u_1
K : Type u_2
inst✝⁶ : CommRing A
S : Submonoid A
hS✝ : S ≤ A⁰
inst✝⁵ : CommRing K
inst✝⁴ : Algebra A K
inst✝³ : IsFractionRing A K
B : Type u_3
inst✝² : CommRing B
inst✝¹ : Algebra A B
inst✝ : IsLocalization S B
hS : S ≤ A⁰
a : A
s : { x // x ∈ S }
⊢ ∃ a_1 s_1 hs,
    ↑↑(mapToFractionRing K S B hS) (IsLocalization.mk' B a s) =
      IsLocalization.mk' K a_1 { val := s_1, property := (_ : s_1 ∈ A⁰) }
[PROOFSTEP]
use a, s, s.2
[GOAL]
case h
A : Type u_1
K : Type u_2
inst✝⁶ : CommRing A
S : Submonoid A
hS✝ : S ≤ A⁰
inst✝⁵ : CommRing K
inst✝⁴ : Algebra A K
inst✝³ : IsFractionRing A K
B : Type u_3
inst✝² : CommRing B
inst✝¹ : Algebra A B
inst✝ : IsLocalization S B
hS : S ≤ A⁰
a : A
s : { x // x ∈ S }
⊢ ↑↑(mapToFractionRing K S B hS) (IsLocalization.mk' B a s) =
    IsLocalization.mk' K a { val := ↑s, property := (_ : ↑s ∈ A⁰) }
[PROOFSTEP]
apply IsLocalization.lift_mk'
[GOAL]
A : Type u_1
K : Type u_2
inst✝⁶ : CommRing A
S : Submonoid A
hS✝ : S ≤ A⁰
inst✝⁵ : CommRing K
inst✝⁴ : Algebra A K
inst✝³ : IsFractionRing A K
B : Type u_3
inst✝² : CommRing B
inst✝¹ : Algebra A B
inst✝ : IsLocalization S B
hS : S ≤ A⁰
x : K
⊢ (∃ a s hs, x = IsLocalization.mk' K a { val := s, property := (_ : s ∈ A⁰) }) →
    x ∈ AlgHom.range (mapToFractionRing K S B hS)
[PROOFSTEP]
rintro ⟨a, s, hs, rfl⟩
[GOAL]
case intro.intro.intro
A : Type u_1
K : Type u_2
inst✝⁶ : CommRing A
S : Submonoid A
hS✝ : S ≤ A⁰
inst✝⁵ : CommRing K
inst✝⁴ : Algebra A K
inst✝³ : IsFractionRing A K
B : Type u_3
inst✝² : CommRing B
inst✝¹ : Algebra A B
inst✝ : IsLocalization S B
hS : S ≤ A⁰
a s : A
hs : s ∈ S
⊢ IsLocalization.mk' K a { val := s, property := (_ : s ∈ A⁰) } ∈ AlgHom.range (mapToFractionRing K S B hS)
[PROOFSTEP]
use IsLocalization.mk' _ a ⟨s, hs⟩
[GOAL]
case h
A : Type u_1
K : Type u_2
inst✝⁶ : CommRing A
S : Submonoid A
hS✝ : S ≤ A⁰
inst✝⁵ : CommRing K
inst✝⁴ : Algebra A K
inst✝³ : IsFractionRing A K
B : Type u_3
inst✝² : CommRing B
inst✝¹ : Algebra A B
inst✝ : IsLocalization S B
hS : S ≤ A⁰
a s : A
hs : s ∈ S
⊢ ↑↑(mapToFractionRing K S B hS) (IsLocalization.mk' B a { val := s, property := hs }) =
    IsLocalization.mk' K a { val := s, property := (_ : s ∈ A⁰) }
[PROOFSTEP]
apply IsLocalization.lift_mk'
[GOAL]
A : Type u_1
K : Type u_2
inst✝⁶ : CommRing A
S : Submonoid A
hS✝ : S ≤ A⁰
inst✝⁵ : CommRing K
inst✝⁴ : Algebra A K
inst✝³ : IsFractionRing A K
B : Type u_3
inst✝² : CommRing B
inst✝¹ : Algebra A B
inst✝ : IsLocalization S B
hS : S ≤ A⁰
⊢ Function.Bijective ↑(AlgHom.rangeRestrict (mapToFractionRing K S B hS))
[PROOFSTEP]
refine' ⟨fun a b h => _, Set.surjective_onto_range⟩
[GOAL]
A : Type u_1
K : Type u_2
inst✝⁶ : CommRing A
S : Submonoid A
hS✝ : S ≤ A⁰
inst✝⁵ : CommRing K
inst✝⁴ : Algebra A K
inst✝³ : IsFractionRing A K
B : Type u_3
inst✝² : CommRing B
inst✝¹ : Algebra A B
inst✝ : IsLocalization S B
hS : S ≤ A⁰
a b : B
h : ↑(AlgHom.rangeRestrict (mapToFractionRing K S B hS)) a = ↑(AlgHom.rangeRestrict (mapToFractionRing K S B hS)) b
⊢ a = b
[PROOFSTEP]
refine' (IsLocalization.lift_injective_iff _).2 (fun a b => _) (Subtype.ext_iff.1 h)
[GOAL]
A : Type u_1
K : Type u_2
inst✝⁶ : CommRing A
S : Submonoid A
hS✝ : S ≤ A⁰
inst✝⁵ : CommRing K
inst✝⁴ : Algebra A K
inst✝³ : IsFractionRing A K
B : Type u_3
inst✝² : CommRing B
inst✝¹ : Algebra A B
inst✝ : IsLocalization S B
hS : S ≤ A⁰
a✝ b✝ : B
h : ↑(AlgHom.rangeRestrict (mapToFractionRing K S B hS)) a✝ = ↑(AlgHom.rangeRestrict (mapToFractionRing K S B hS)) b✝
a b : A
⊢ ↑(algebraMap A B) a = ↑(algebraMap A B) b ↔ ↑(algebraMap A K) a = ↑(algebraMap A K) b
[PROOFSTEP]
exact ⟨fun h => congr_arg _ (IsLocalization.injective _ hS h), fun h => congr_arg _ (IsFractionRing.injective A K h)⟩
[GOAL]
A : Type u_1
K : Type u_2
inst✝³ : CommRing A
S : Submonoid A
hS✝ : S ≤ A⁰
inst✝² : CommRing K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
hS : S ≤ A⁰
⊢ {x | ∃ a s hs, x = IsLocalization.mk' K a { val := s, property := (_ : s ∈ A⁰) }} =
    ↑(AlgHom.range (mapToFractionRing K S (Localization S) hS))
[PROOFSTEP]
ext
[GOAL]
case h
A : Type u_1
K : Type u_2
inst✝³ : CommRing A
S : Submonoid A
hS✝ : S ≤ A⁰
inst✝² : CommRing K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
hS : S ≤ A⁰
x✝ : K
⊢ x✝ ∈ {x | ∃ a s hs, x = IsLocalization.mk' K a { val := s, property := (_ : s ∈ A⁰) }} ↔
    x✝ ∈ ↑(AlgHom.range (mapToFractionRing K S (Localization S) hS))
[PROOFSTEP]
symm
[GOAL]
case h
A : Type u_1
K : Type u_2
inst✝³ : CommRing A
S : Submonoid A
hS✝ : S ≤ A⁰
inst✝² : CommRing K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
hS : S ≤ A⁰
x✝ : K
⊢ x✝ ∈ ↑(AlgHom.range (mapToFractionRing K S (Localization S) hS)) ↔
    x✝ ∈ {x | ∃ a s hs, x = IsLocalization.mk' K a { val := s, property := (_ : s ∈ A⁰) }}
[PROOFSTEP]
apply mem_range_mapToFractionRing_iff
[GOAL]
A : Type u_1
K : Type u_2
inst✝³ : CommRing A
S : Submonoid A
hS : S ≤ A⁰
inst✝² : CommRing K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
⊢ IsLocalization S { x // x ∈ subalgebra K S hS }
[PROOFSTEP]
dsimp only [Localization.subalgebra]
[GOAL]
A : Type u_1
K : Type u_2
inst✝³ : CommRing A
S : Submonoid A
hS : S ≤ A⁰
inst✝² : CommRing K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
⊢ IsLocalization S
    { x //
      x ∈
        Subalgebra.copy (AlgHom.range (mapToFractionRing K S (Localization S) hS))
          {x | ∃ a s hs, x = IsLocalization.mk' K a { val := s, property := (_ : s ∈ A⁰) }}
          (_ :
            {x | ∃ a s hs, x = IsLocalization.mk' K a { val := s, property := (_ : s ∈ A⁰) }} =
              ↑(AlgHom.range (mapToFractionRing K S (Localization S) hS))) }
[PROOFSTEP]
rw [Subalgebra.copy_eq]
[GOAL]
A : Type u_1
K : Type u_2
inst✝³ : CommRing A
S : Submonoid A
hS : S ≤ A⁰
inst✝² : CommRing K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
⊢ IsLocalization S { x // x ∈ AlgHom.range (mapToFractionRing K S (Localization S) hS) }
[PROOFSTEP]
infer_instance
[GOAL]
A : Type u_1
K : Type u_2
inst✝⁶ : CommRing A
S : Submonoid A
hS : S ≤ A⁰
inst✝⁵ : Field K
inst✝⁴ : Algebra A K
inst✝³ : IsFractionRing A K
B : Type u_3
inst✝² : CommRing B
inst✝¹ : Algebra A B
inst✝ : IsLocalization S B
x : K
⊢ x ∈ AlgHom.range (mapToFractionRing K S B hS) ↔ ∃ a s x_1, x = ↑(algebraMap A K) a * (↑(algebraMap A K) s)⁻¹
[PROOFSTEP]
rw [mem_range_mapToFractionRing_iff]
[GOAL]
A : Type u_1
K : Type u_2
inst✝⁶ : CommRing A
S : Submonoid A
hS : S ≤ A⁰
inst✝⁵ : Field K
inst✝⁴ : Algebra A K
inst✝³ : IsFractionRing A K
B : Type u_3
inst✝² : CommRing B
inst✝¹ : Algebra A B
inst✝ : IsLocalization S B
x : K
⊢ (∃ a s hs, x = IsLocalization.mk' K a { val := s, property := (_ : s ∈ A⁰) }) ↔
    ∃ a s x_1, x = ↑(algebraMap A K) a * (↑(algebraMap A K) s)⁻¹
[PROOFSTEP]
convert Iff.rfl
[GOAL]
case h.e'_2.h.e'_2.h.h.e'_2.h.h.e'_2.h.h.e'_3
A : Type u_1
K : Type u_2
inst✝⁶ : CommRing A
S : Submonoid A
hS : S ≤ A⁰
inst✝⁵ : Field K
inst✝⁴ : Algebra A K
inst✝³ : IsFractionRing A K
B : Type u_3
inst✝² : CommRing B
inst✝¹ : Algebra A B
inst✝ : IsLocalization S B
x : K
x✝² x✝¹ : A
x✝ : x✝¹ ∈ S
⊢ ↑(algebraMap A K) x✝² * (↑(algebraMap A K) x✝¹)⁻¹ =
    IsLocalization.mk' K x✝² { val := x✝¹, property := (_ : x✝¹ ∈ A⁰) }
[PROOFSTEP]
congr
[GOAL]
case h.e'_2.h.e'_2.h.h.e'_2.h.h.e'_2.h.h.e'_3.e_a
A : Type u_1
K : Type u_2
inst✝⁶ : CommRing A
S : Submonoid A
hS : S ≤ A⁰
inst✝⁵ : Field K
inst✝⁴ : Algebra A K
inst✝³ : IsFractionRing A K
B : Type u_3
inst✝² : CommRing B
inst✝¹ : Algebra A B
inst✝ : IsLocalization S B
x : K
x✝² x✝¹ : A
x✝ : x✝¹ ∈ S
⊢ (↑(algebraMap A K) x✝¹)⁻¹ =
    ↑(↑(IsUnit.liftRight
              (MonoidHom.restrict (Submonoid.LocalizationMap.toMap (IsLocalization.toLocalizationMap A⁰ K)) A⁰)
              (_ :
                ∀ (y : { x // x ∈ A⁰ }),
                  IsUnit (↑(Submonoid.LocalizationMap.toMap (IsLocalization.toLocalizationMap A⁰ K)) ↑y)))
          { val := x✝¹, property := (_ : x✝¹ ∈ A⁰) })⁻¹
[PROOFSTEP]
rw [Units.val_inv_eq_inv_val]
[GOAL]
case h.e'_2.h.e'_2.h.h.e'_2.h.h.e'_2.h.h.e'_3.e_a
A : Type u_1
K : Type u_2
inst✝⁶ : CommRing A
S : Submonoid A
hS : S ≤ A⁰
inst✝⁵ : Field K
inst✝⁴ : Algebra A K
inst✝³ : IsFractionRing A K
B : Type u_3
inst✝² : CommRing B
inst✝¹ : Algebra A B
inst✝ : IsLocalization S B
x : K
x✝² x✝¹ : A
x✝ : x✝¹ ∈ S
⊢ (↑(algebraMap A K) x✝¹)⁻¹ =
    (↑(↑(IsUnit.liftRight
              (MonoidHom.restrict (Submonoid.LocalizationMap.toMap (IsLocalization.toLocalizationMap A⁰ K)) A⁰)
              (_ :
                ∀ (y : { x // x ∈ A⁰ }),
                  IsUnit (↑(Submonoid.LocalizationMap.toMap (IsLocalization.toLocalizationMap A⁰ K)) ↑y)))
          { val := x✝¹, property := (_ : x✝¹ ∈ A⁰) }))⁻¹
[PROOFSTEP]
rfl
[GOAL]
A : Type u_1
K : Type u_2
inst✝³ : CommRing A
S : Submonoid A
hS : S ≤ A⁰
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
⊢ {x | ∃ a s x_1, x = ↑(algebraMap A K) a * (↑(algebraMap A K) s)⁻¹} =
    ↑(AlgHom.range (mapToFractionRing K S (Localization S) hS))
[PROOFSTEP]
ext
[GOAL]
case h
A : Type u_1
K : Type u_2
inst✝³ : CommRing A
S : Submonoid A
hS : S ≤ A⁰
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
x✝ : K
⊢ x✝ ∈ {x | ∃ a s x_1, x = ↑(algebraMap A K) a * (↑(algebraMap A K) s)⁻¹} ↔
    x✝ ∈ ↑(AlgHom.range (mapToFractionRing K S (Localization S) hS))
[PROOFSTEP]
symm
[GOAL]
case h
A : Type u_1
K : Type u_2
inst✝³ : CommRing A
S : Submonoid A
hS : S ≤ A⁰
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
x✝ : K
⊢ x✝ ∈ ↑(AlgHom.range (mapToFractionRing K S (Localization S) hS)) ↔
    x✝ ∈ {x | ∃ a s x_1, x = ↑(algebraMap A K) a * (↑(algebraMap A K) s)⁻¹}
[PROOFSTEP]
apply mem_range_mapToFractionRing_iff_ofField
[GOAL]
A : Type u_1
K : Type u_2
inst✝³ : CommRing A
S : Submonoid A
hS : S ≤ A⁰
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
⊢ IsLocalization S { x // x ∈ ofField K S hS }
[PROOFSTEP]
dsimp only [Localization.subalgebra.ofField]
[GOAL]
A : Type u_1
K : Type u_2
inst✝³ : CommRing A
S : Submonoid A
hS : S ≤ A⁰
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
⊢ IsLocalization S
    { x //
      x ∈
        Subalgebra.copy (AlgHom.range (mapToFractionRing K S (Localization S) hS))
          {x | ∃ a s x_1, x = ↑(algebraMap A K) a * (↑(algebraMap A K) s)⁻¹}
          (_ :
            {x | ∃ a s x_1, x = ↑(algebraMap A K) a * (↑(algebraMap A K) s)⁻¹} =
              ↑(AlgHom.range (mapToFractionRing K S (Localization S) hS))) }
[PROOFSTEP]
rw [Subalgebra.copy_eq]
[GOAL]
A : Type u_1
K : Type u_2
inst✝³ : CommRing A
S : Submonoid A
hS : S ≤ A⁰
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
⊢ IsLocalization S { x // x ∈ AlgHom.range (mapToFractionRing K S (Localization S) hS) }
[PROOFSTEP]
infer_instance


[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
f : Filter α
g : Filter β
⊢ Set.univ ∈ {s | ∀ᶠ (a : α) in f, ∀ᶠ (b : β) in g, (a, b) ∈ s}
[PROOFSTEP]
simp only [Set.mem_setOf_eq, Set.mem_univ, eventually_true]