[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X✝ : C
Y Y' : D
X : C
⊢ ↑(homEquiv adj X (F.obj X)) (𝟙 (F.obj X)) = NatTrans.app adj.unit X
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X✝ : C
Y Y' X : D
⊢ ↑(homEquiv adj (G.obj X) X).symm (𝟙 (G.obj X)) = NatTrans.app adj.counit X
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
f : X' ⟶ X
g : X ⟶ G.obj Y
⊢ ↑(homEquiv adj X' Y).symm (f ≫ g) = F.map f ≫ ↑(homEquiv adj X Y).symm g
[PROOFSTEP]
rw [homEquiv_counit, F.map_comp, assoc, adj.homEquiv_counit.symm]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
f : X' ⟶ X
g : F.obj X ⟶ Y
⊢ ↑(homEquiv adj X' Y) (F.map f ≫ g) = f ≫ ↑(homEquiv adj X Y) g
[PROOFSTEP]
rw [← Equiv.eq_symm_apply]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
f : X' ⟶ X
g : F.obj X ⟶ Y
⊢ F.map f ≫ g = ↑(homEquiv adj X' Y).symm (f ≫ ↑(homEquiv adj X Y) g)
[PROOFSTEP]
simp only [Equiv.symm_apply_apply, eq_self_iff_true, homEquiv_naturality_left_symm]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
f : F.obj X ⟶ Y
g : Y ⟶ Y'
⊢ ↑(homEquiv adj X Y') (f ≫ g) = ↑(homEquiv adj X Y) f ≫ G.map g
[PROOFSTEP]
rw [homEquiv_unit, G.map_comp, ← assoc, ← homEquiv_unit]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
f : X ⟶ G.obj Y
g : Y ⟶ Y'
⊢ ↑(homEquiv adj X Y').symm (f ≫ G.map g) = ↑(homEquiv adj X Y).symm f ≫ g
[PROOFSTEP]
rw [Equiv.symm_apply_eq]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
f : X ⟶ G.obj Y
g : Y ⟶ Y'
⊢ f ≫ G.map g = ↑(homEquiv adj X Y') (↑(homEquiv adj X Y).symm f ≫ g)
[PROOFSTEP]
simp only [homEquiv_naturality_right, eq_self_iff_true, Equiv.apply_symm_apply]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
⊢ whiskerRight adj.unit F ≫ whiskerLeft F adj.counit = 𝟙 (𝟭 C ⋙ F)
[PROOFSTEP]
ext
[GOAL]
case w.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
x✝ : C
⊢ NatTrans.app (whiskerRight adj.unit F ≫ whiskerLeft F adj.counit) x✝ = NatTrans.app (𝟙 (𝟭 C ⋙ F)) x✝
[PROOFSTEP]
dsimp
[GOAL]
case w.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
x✝ : C
⊢ F.map (NatTrans.app adj.unit x✝) ≫ NatTrans.app adj.counit (F.obj x✝) = 𝟙 (F.obj x✝)
[PROOFSTEP]
erw [← adj.homEquiv_counit, Equiv.symm_apply_eq, adj.homEquiv_unit]
[GOAL]
case w.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
x✝ : C
⊢ NatTrans.app adj.unit x✝ = NatTrans.app adj.unit x✝ ≫ G.map (𝟙 (F.obj x✝))
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
⊢ whiskerLeft G adj.unit ≫ whiskerRight adj.counit G = 𝟙 (G ⋙ 𝟭 C)
[PROOFSTEP]
ext
[GOAL]
case w.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' x✝ : D
⊢ NatTrans.app (whiskerLeft G adj.unit ≫ whiskerRight adj.counit G) x✝ = NatTrans.app (𝟙 (G ⋙ 𝟭 C)) x✝
[PROOFSTEP]
dsimp
[GOAL]
case w.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' x✝ : D
⊢ NatTrans.app adj.unit (G.obj x✝) ≫ G.map (NatTrans.app adj.counit x✝) = 𝟙 (G.obj x✝)
[PROOFSTEP]
erw [← adj.homEquiv_unit, ← Equiv.eq_symm_apply, adj.homEquiv_counit]
[GOAL]
case w.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' x✝ : D
⊢ NatTrans.app adj.counit x✝ = F.map (𝟙 (G.obj x✝)) ≫ NatTrans.app adj.counit x✝
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
A : C
B : D
f : F.obj A ⟶ B
g : A ⟶ G.obj B
h : ↑(homEquiv adj A B) f = g
⊢ f = ↑(homEquiv adj A B).symm g
[PROOFSTEP]
cases h
[GOAL]
case refl
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
A : C
B : D
f : F.obj A ⟶ B
⊢ f = ↑(homEquiv adj A B).symm (↑(homEquiv adj A B) f)
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
A : C
B : D
f : F.obj A ⟶ B
g : A ⟶ G.obj B
h : f = ↑(homEquiv adj A B).symm g
⊢ ↑(homEquiv adj A B) f = g
[PROOFSTEP]
cases h
[GOAL]
case refl
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
A : C
B : D
g : A ⟶ G.obj B
⊢ ↑(homEquiv adj A B) (↑(homEquiv adj A B).symm g) = g
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
A : C
B : D
f : F.obj A ⟶ B
g : A ⟶ G.obj B
h : g = ↑(homEquiv adj A B) f
⊢ ↑(homEquiv adj A B).symm g = f
[PROOFSTEP]
cases h
[GOAL]
case refl
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
A : C
B : D
f : F.obj A ⟶ B
⊢ ↑(homEquiv adj A B).symm (↑(homEquiv adj A B) f) = f
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
A : C
B : D
f : F.obj A ⟶ B
g : A ⟶ G.obj B
h : ↑(homEquiv adj A B).symm g = f
⊢ g = ↑(homEquiv adj A B) f
[PROOFSTEP]
cases h
[GOAL]
case refl
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
A : C
B : D
g : A ⟶ G.obj B
⊢ g = ↑(homEquiv adj A B) (↑(homEquiv adj A B).symm g)
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X' X : C
Y Y' : D
f : X' ⟶ X
g : F.obj X ⟶ Y
⊢ ↑(homEquiv adj X' (F.obj X)) (F.map f) ≫ G.map g = f ≫ ↑(homEquiv adj X Y) g
[PROOFSTEP]
rw [← homEquiv_naturality_right, ← Equiv.eq_symm_apply]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X' X : C
Y Y' : D
f : X' ⟶ X
g : F.obj X ⟶ Y
⊢ F.map f ≫ g = ↑(homEquiv adj X' Y).symm (f ≫ ↑(homEquiv adj X Y) g)
[PROOFSTEP]
simp
  -- @[simp] -- Porting note: LHS simplifies, added aux lemma above
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X' X : C
Y Y' : D
f : X' ⟶ X
g : F.obj X ⟶ Y
⊢ ↑(homEquiv adj X' Y) (F.map f ≫ g) = f ≫ ↑(homEquiv adj X Y) g
[PROOFSTEP]
rw [← Equiv.eq_symm_apply]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X' X : C
Y Y' : D
f : X' ⟶ X
g : F.obj X ⟶ Y
⊢ F.map f ≫ g = ↑(homEquiv adj X' Y).symm (f ≫ ↑(homEquiv adj X Y) g)
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X' X : C
Y Y' : D
f : X ⟶ G.obj Y
g : Y ⟶ Y'
⊢ F.map f ≫ ↑(homEquiv adj (G.obj Y) Y').symm (G.map g) = ↑(homEquiv adj X Y).symm f ≫ g
[PROOFSTEP]
rw [← homEquiv_naturality_left_symm, Equiv.symm_apply_eq]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X' X : C
Y Y' : D
f : X ⟶ G.obj Y
g : Y ⟶ Y'
⊢ f ≫ G.map g = ↑(homEquiv adj X Y') (↑(homEquiv adj X Y).symm f ≫ g)
[PROOFSTEP]
simp
  -- @[simp] -- Porting note: LHS simplifies, added aux lemma above
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X' X : C
Y Y' : D
f : X ⟶ G.obj Y
g : Y ⟶ Y'
⊢ ↑(homEquiv adj X Y').symm (f ≫ G.map g) = ↑(homEquiv adj X Y).symm f ≫ g
[PROOFSTEP]
rw [Equiv.symm_apply_eq]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X' X : C
Y Y' : D
f : X ⟶ G.obj Y
g : Y ⟶ Y'
⊢ f ≫ G.map g = ↑(homEquiv adj X Y') (↑(homEquiv adj X Y).symm f ≫ g)
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
⊢ ∀ ⦃X Y : C⦄ (f : X ⟶ Y),
    (𝟭 C).map f ≫ (fun X => ↑(CoreHomEquiv.homEquiv adj X (F.obj X)) (𝟙 (F.obj X))) Y =
      (fun X => ↑(CoreHomEquiv.homEquiv adj X (F.obj X)) (𝟙 (F.obj X))) X ≫ (F ⋙ G).map f
[PROOFSTEP]
intros
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
⊢ (𝟭 C).map f✝ ≫ (fun X => ↑(CoreHomEquiv.homEquiv adj X (F.obj X)) (𝟙 (F.obj X))) Y✝ =
    (fun X => ↑(CoreHomEquiv.homEquiv adj X (F.obj X)) (𝟙 (F.obj X))) X✝ ≫ (F ⋙ G).map f✝
[PROOFSTEP]
erw [← adj.homEquiv_naturality_left, ← adj.homEquiv_naturality_right]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
⊢ ↑(CoreHomEquiv.homEquiv adj ((𝟭 C).obj X✝) (F.obj Y✝)) (F.map ((𝟭 C).map f✝) ≫ 𝟙 (F.obj Y✝)) =
    ↑(CoreHomEquiv.homEquiv adj ((𝟭 C).obj X✝) (F.obj Y✝)) (𝟙 (F.obj X✝) ≫ F.map f✝)
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
⊢ ↑(CoreHomEquiv.homEquiv adj X✝ (F.obj Y✝)) (F.map f✝ ≫ 𝟙 (F.obj Y✝)) =
    ↑(CoreHomEquiv.homEquiv adj X✝ (F.obj Y✝)) (𝟙 (F.obj X✝) ≫ 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
G : D ⥤ C
adj : CoreHomEquiv F G
⊢ ∀ ⦃X Y : D⦄ (f : X ⟶ Y),
    (G ⋙ F).map f ≫ (fun Y => Equiv.invFun (CoreHomEquiv.homEquiv adj (G.obj Y) ((𝟭 D).obj Y)) (𝟙 (G.obj Y))) Y =
      (fun Y => Equiv.invFun (CoreHomEquiv.homEquiv adj (G.obj Y) ((𝟭 D).obj Y)) (𝟙 (G.obj Y))) X ≫ (𝟭 D).map f
[PROOFSTEP]
intros
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X✝ Y✝ : D
f✝ : X✝ ⟶ Y✝
⊢ (G ⋙ F).map f✝ ≫ (fun Y => Equiv.invFun (CoreHomEquiv.homEquiv adj (G.obj Y) ((𝟭 D).obj Y)) (𝟙 (G.obj Y))) Y✝ =
    (fun Y => Equiv.invFun (CoreHomEquiv.homEquiv adj (G.obj Y) ((𝟭 D).obj Y)) (𝟙 (G.obj Y))) X✝ ≫ (𝟭 D).map f✝
[PROOFSTEP]
erw [← adj.homEquiv_naturality_left_symm, ← adj.homEquiv_naturality_right_symm]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X✝ Y✝ : D
f✝ : X✝ ⟶ Y✝
⊢ ↑(CoreHomEquiv.homEquiv adj (G.obj X✝) ((𝟭 D).obj Y✝)).symm (G.map f✝ ≫ 𝟙 (G.obj Y✝)) =
    ↑(CoreHomEquiv.homEquiv adj (G.obj X✝) ((𝟭 D).obj Y✝)).symm (𝟙 (G.obj X✝) ≫ G.map ((𝟭 D).map f✝))
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X✝ Y✝ : D
f✝ : X✝ ⟶ Y✝
⊢ ↑(CoreHomEquiv.homEquiv adj (G.obj X✝) Y✝).symm (G.map f✝ ≫ 𝟙 (G.obj Y✝)) =
    ↑(CoreHomEquiv.homEquiv adj (G.obj X✝) Y✝).symm (𝟙 (G.obj X✝) ≫ G.map f✝)
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X : C
Y : D
f : F.obj X ⟶ Y
⊢ ↑(CoreHomEquiv.homEquiv adj X Y) f =
    NatTrans.app (NatTrans.mk fun X => ↑(CoreHomEquiv.homEquiv adj X (F.obj X)) (𝟙 (F.obj X))) X ≫ G.map f
[PROOFSTEP]
erw [← adj.homEquiv_naturality_right]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X : C
Y : D
f : F.obj X ⟶ Y
⊢ ↑(CoreHomEquiv.homEquiv adj X Y) f = ↑(CoreHomEquiv.homEquiv adj ((𝟭 C).obj X) Y) (𝟙 (F.obj X) ≫ f)
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X : C
Y : D
f : X ⟶ G.obj Y
⊢ ↑(CoreHomEquiv.homEquiv adj X Y).symm f =
    F.map f ≫
      NatTrans.app (NatTrans.mk fun Y => Equiv.invFun (CoreHomEquiv.homEquiv adj (G.obj Y) ((𝟭 D).obj Y)) (𝟙 (G.obj Y)))
        Y
[PROOFSTEP]
erw [← adj.homEquiv_naturality_left_symm]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X : C
Y : D
f : X ⟶ G.obj Y
⊢ ↑(CoreHomEquiv.homEquiv adj X Y).symm f = ↑(CoreHomEquiv.homEquiv adj X ((𝟭 D).obj Y)).symm (f ≫ 𝟙 (G.obj Y))
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreUnitCounit F G
X : C
Y : D
f : F.obj X ⟶ Y
⊢ (fun g => F.map g ≫ NatTrans.app adj.counit Y) ((fun f => NatTrans.app adj.unit X ≫ G.map f) f) = f
[PROOFSTEP]
change F.map (_ ≫ _) ≫ _ = _
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreUnitCounit F G
X : C
Y : D
f : F.obj X ⟶ Y
⊢ F.map (NatTrans.app adj.unit X ≫ G.map f) ≫ NatTrans.app adj.counit Y = f
[PROOFSTEP]
rw [F.map_comp, assoc, ← Functor.comp_map, adj.counit.naturality, ← assoc]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreUnitCounit F G
X : C
Y : D
f : F.obj X ⟶ Y
⊢ (F.map (NatTrans.app adj.unit X) ≫ NatTrans.app adj.counit (F.obj X)) ≫ (𝟭 D).map f = f
[PROOFSTEP]
convert id_comp f
[GOAL]
case h.e'_2.h.e'_6.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreUnitCounit F G
X : C
Y : D
f : F.obj X ⟶ Y
e_4✝ : (𝟭 D).obj (F.obj X) = F.obj X
⊢ F.map (NatTrans.app adj.unit X) ≫ NatTrans.app adj.counit (F.obj X) = 𝟙 (F.obj X)
[PROOFSTEP]
have t := congrArg (fun (s : NatTrans (𝟭 C ⋙ F) (F ⋙ 𝟭 D)) => s.app X) adj.left_triangle
[GOAL]
case h.e'_2.h.e'_6.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreUnitCounit F G
X : C
Y : D
f : F.obj X ⟶ Y
e_4✝ : (𝟭 D).obj (F.obj X) = F.obj X
t :
  (fun s => NatTrans.app s X) (whiskerRight adj.unit F ≫ (Functor.associator F G F).hom ≫ whiskerLeft F adj.counit) =
    (fun s => NatTrans.app s X) (NatTrans.id (𝟭 C ⋙ F))
⊢ F.map (NatTrans.app adj.unit X) ≫ NatTrans.app adj.counit (F.obj X) = 𝟙 (F.obj X)
[PROOFSTEP]
dsimp at t
[GOAL]
case h.e'_2.h.e'_6.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreUnitCounit F G
X : C
Y : D
f : F.obj X ⟶ Y
e_4✝ : (𝟭 D).obj (F.obj X) = F.obj X
t : F.map (NatTrans.app adj.unit X) ≫ 𝟙 (F.obj (G.obj (F.obj X))) ≫ NatTrans.app adj.counit (F.obj X) = 𝟙 (F.obj X)
⊢ F.map (NatTrans.app adj.unit X) ≫ NatTrans.app adj.counit (F.obj X) = 𝟙 (F.obj X)
[PROOFSTEP]
simp only [id_comp] at t
[GOAL]
case h.e'_2.h.e'_6.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreUnitCounit F G
X : C
Y : D
f : F.obj X ⟶ Y
e_4✝ : (𝟭 D).obj (F.obj X) = F.obj X
t : F.map (NatTrans.app adj.unit X) ≫ NatTrans.app adj.counit (F.obj X) = 𝟙 (F.obj X)
⊢ F.map (NatTrans.app adj.unit X) ≫ NatTrans.app adj.counit (F.obj X) = 𝟙 (F.obj X)
[PROOFSTEP]
exact t
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreUnitCounit F G
X : C
Y : D
g : X ⟶ G.obj Y
⊢ (fun f => NatTrans.app adj.unit X ≫ G.map f) ((fun g => F.map g ≫ NatTrans.app adj.counit Y) g) = g
[PROOFSTEP]
change _ ≫ G.map (_ ≫ _) = _
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreUnitCounit F G
X : C
Y : D
g : X ⟶ G.obj Y
⊢ NatTrans.app adj.unit X ≫ G.map (F.map g ≫ NatTrans.app adj.counit Y) = g
[PROOFSTEP]
rw [G.map_comp, ← assoc, ← Functor.comp_map, ← adj.unit.naturality, assoc]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreUnitCounit F G
X : C
Y : D
g : X ⟶ G.obj Y
⊢ (𝟭 C).map g ≫ NatTrans.app adj.unit (G.obj Y) ≫ G.map (NatTrans.app adj.counit Y) = g
[PROOFSTEP]
convert comp_id g
[GOAL]
case h.e'_2.h.e'_7.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreUnitCounit F G
X : C
Y : D
g : X ⟶ G.obj Y
e_4✝ : (𝟭 C).obj (G.obj Y) = G.obj Y
⊢ NatTrans.app adj.unit (G.obj Y) ≫ G.map (NatTrans.app adj.counit Y) = 𝟙 (G.obj Y)
[PROOFSTEP]
have t := congrArg (fun t : NatTrans (G ⋙ 𝟭 C) (𝟭 D ⋙ G) => t.app Y) adj.right_triangle
[GOAL]
case h.e'_2.h.e'_7.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreUnitCounit F G
X : C
Y : D
g : X ⟶ G.obj Y
e_4✝ : (𝟭 C).obj (G.obj Y) = G.obj Y
t :
  (fun t => NatTrans.app t Y) (whiskerLeft G adj.unit ≫ (Functor.associator G F G).inv ≫ whiskerRight adj.counit G) =
    (fun t => NatTrans.app t Y) (NatTrans.id (G ⋙ 𝟭 C))
⊢ NatTrans.app adj.unit (G.obj Y) ≫ G.map (NatTrans.app adj.counit Y) = 𝟙 (G.obj Y)
[PROOFSTEP]
dsimp at t
[GOAL]
case h.e'_2.h.e'_7.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreUnitCounit F G
X : C
Y : D
g : X ⟶ G.obj Y
e_4✝ : (𝟭 C).obj (G.obj Y) = G.obj Y
t : NatTrans.app adj.unit (G.obj Y) ≫ 𝟙 (G.obj (F.obj (G.obj Y))) ≫ G.map (NatTrans.app adj.counit Y) = 𝟙 (G.obj Y)
⊢ NatTrans.app adj.unit (G.obj Y) ≫ G.map (NatTrans.app adj.counit Y) = 𝟙 (G.obj Y)
[PROOFSTEP]
simp only [id_comp] at t
[GOAL]
case h.e'_2.h.e'_7.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreUnitCounit F G
X : C
Y : D
g : X ⟶ G.obj Y
e_4✝ : (𝟭 C).obj (G.obj Y) = G.obj Y
t : NatTrans.app adj.unit (G.obj Y) ≫ G.map (NatTrans.app adj.counit Y) = 𝟙 (G.obj Y)
⊢ NatTrans.app adj.unit (G.obj Y) ≫ G.map (NatTrans.app adj.counit Y) = 𝟙 (G.obj Y)
[PROOFSTEP]
exact t
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F✝ : C ⥤ D
G : D ⥤ C
F F' : C ⥤ D
iso : F ≅ F'
X : C
Y : D
f : F.obj X ⟶ Y
⊢ (fun g => NatTrans.app iso.hom X ≫ g) ((fun f => NatTrans.app iso.inv X ≫ 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
G : D ⥤ C
F F' : C ⥤ D
iso : F ≅ F'
X : C
Y : D
g : F'.obj X ⟶ Y
⊢ (fun f => NatTrans.app iso.inv X ≫ f) ((fun g => NatTrans.app iso.hom X ≫ g) g) = g
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G✝ G G' : D ⥤ C
iso : G ≅ G'
X : C
Y : D
f : X ⟶ G.obj Y
⊢ (fun g => g ≫ NatTrans.app iso.inv Y) ((fun f => f ≫ NatTrans.app iso.hom Y) f) = f
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G✝ G G' : D ⥤ C
iso : G ≅ G'
X : C
Y : D
g : X ⟶ G'.obj Y
⊢ (fun f => f ≫ NatTrans.app iso.hom Y) ((fun g => g ≫ NatTrans.app iso.inv Y) g) = g
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
F_obj : C → D
e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
he : ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y), ↑(e X Y') (h ≫ g) = ↑(e X Y) h ≫ G.map g
X : C
Y Y' : D
f : X ⟶ G.obj Y
g : Y ⟶ Y'
⊢ ↑(e X Y').symm (f ≫ G.map g) = ↑(e X Y).symm f ≫ g
[PROOFSTEP]
intros
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
F_obj : C → D
e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
he : ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y), ↑(e X Y') (h ≫ g) = ↑(e X Y) h ≫ G.map g
X : C
Y Y' : D
f : X ⟶ G.obj Y
g : Y ⟶ Y'
⊢ ↑(e X Y').symm (f ≫ G.map g) = ↑(e X Y).symm f ≫ g
[PROOFSTEP]
rw [Equiv.symm_apply_eq, he]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
F_obj : C → D
e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
he : ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y), ↑(e X Y') (h ≫ g) = ↑(e X Y) h ≫ G.map g
X : C
Y Y' : D
f : X ⟶ G.obj Y
g : Y ⟶ Y'
⊢ f ≫ G.map g = ↑(e X Y) (↑(e X Y).symm f) ≫ G.map g
[PROOFSTEP]
simp
  -- #align category_theory.adjunction.he' category_theory.adjunction.he'
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
F_obj : C → D
e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
he : ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y), ↑(e X Y') (h ≫ g) = ↑(e X Y) h ≫ G.map g
X✝ Y✝ Z✝ : C
f : X✝ ⟶ Y✝
f' : Y✝ ⟶ Z✝
⊢ { obj := F_obj, map := fun {X X'} f => ↑(e X (F_obj X')).symm (f ≫ ↑(e X' (F_obj X')) (𝟙 (F_obj X'))) }.map (f ≫ f') =
    { obj := F_obj, map := fun {X X'} f => ↑(e X (F_obj X')).symm (f ≫ ↑(e X' (F_obj X')) (𝟙 (F_obj X'))) }.map f ≫
      { obj := F_obj, map := fun {X X'} f => ↑(e X (F_obj X')).symm (f ≫ ↑(e X' (F_obj X')) (𝟙 (F_obj X'))) }.map f'
[PROOFSTEP]
rw [Equiv.symm_apply_eq, he, Equiv.apply_symm_apply]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
F_obj : C → D
e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
he : ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y), ↑(e X Y') (h ≫ g) = ↑(e X Y) h ≫ G.map g
X✝ Y✝ Z✝ : C
f : X✝ ⟶ Y✝
f' : Y✝ ⟶ Z✝
⊢ (f ≫ f') ≫ ↑(e Z✝ (F_obj Z✝)) (𝟙 (F_obj Z✝)) =
    (f ≫ ↑(e Y✝ (F_obj Y✝)) (𝟙 (F_obj Y✝))) ≫
      G.map
        ({ obj := F_obj, map := fun {X X'} f => ↑(e X (F_obj X')).symm (f ≫ ↑(e X' (F_obj X')) (𝟙 (F_obj X'))) }.map f')
[PROOFSTEP]
conv =>
  rhs
  rw [assoc, ← he, id_comp, Equiv.apply_symm_apply]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
F_obj : C → D
e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
he : ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y), ↑(e X Y') (h ≫ g) = ↑(e X Y) h ≫ G.map g
X✝ Y✝ Z✝ : C
f : X✝ ⟶ Y✝
f' : Y✝ ⟶ Z✝
| (f ≫ f') ≫ ↑(e Z✝ (F_obj Z✝)) (𝟙 (F_obj Z✝)) =
    (f ≫ ↑(e Y✝ (F_obj Y✝)) (𝟙 (F_obj Y✝))) ≫
      G.map
        ({ obj := F_obj, map := fun {X X'} f => ↑(e X (F_obj X')).symm (f ≫ ↑(e X' (F_obj X')) (𝟙 (F_obj X'))) }.map f')
[PROOFSTEP]
  rhs
  rw [assoc, ← he, id_comp, Equiv.apply_symm_apply]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
F_obj : C → D
e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
he : ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y), ↑(e X Y') (h ≫ g) = ↑(e X Y) h ≫ G.map g
X✝ Y✝ Z✝ : C
f : X✝ ⟶ Y✝
f' : Y✝ ⟶ Z✝
| (f ≫ f') ≫ ↑(e Z✝ (F_obj Z✝)) (𝟙 (F_obj Z✝)) =
    (f ≫ ↑(e Y✝ (F_obj Y✝)) (𝟙 (F_obj Y✝))) ≫
      G.map
        ({ obj := F_obj, map := fun {X X'} f => ↑(e X (F_obj X')).symm (f ≫ ↑(e X' (F_obj X')) (𝟙 (F_obj X'))) }.map f')
[PROOFSTEP]
  rhs
  rw [assoc, ← he, id_comp, Equiv.apply_symm_apply]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
F_obj : C → D
e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
he : ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y), ↑(e X Y') (h ≫ g) = ↑(e X Y) h ≫ G.map g
X✝ Y✝ Z✝ : C
f : X✝ ⟶ Y✝
f' : Y✝ ⟶ Z✝
| (f ≫ f') ≫ ↑(e Z✝ (F_obj Z✝)) (𝟙 (F_obj Z✝)) =
    (f ≫ ↑(e Y✝ (F_obj Y✝)) (𝟙 (F_obj Y✝))) ≫
      G.map
        ({ obj := F_obj, map := fun {X X'} f => ↑(e X (F_obj X')).symm (f ≫ ↑(e X' (F_obj X')) (𝟙 (F_obj X'))) }.map f')
[PROOFSTEP]
rhs
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
F_obj : C → D
e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
he : ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y), ↑(e X Y') (h ≫ g) = ↑(e X Y) h ≫ G.map g
X✝ Y✝ Z✝ : C
f : X✝ ⟶ Y✝
f' : Y✝ ⟶ Z✝
| (f ≫ ↑(e Y✝ (F_obj Y✝)) (𝟙 (F_obj Y✝))) ≫
    G.map
      ({ obj := F_obj, map := fun {X X'} f => ↑(e X (F_obj X')).symm (f ≫ ↑(e X' (F_obj X')) (𝟙 (F_obj X'))) }.map f')
[PROOFSTEP]
rw [assoc, ← he, id_comp, Equiv.apply_symm_apply]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
F_obj : C → D
e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
he : ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y), ↑(e X Y') (h ≫ g) = ↑(e X Y) h ≫ G.map g
X✝ Y✝ Z✝ : C
f : X✝ ⟶ Y✝
f' : Y✝ ⟶ Z✝
⊢ (f ≫ f') ≫ ↑(e Z✝ (F_obj Z✝)) (𝟙 (F_obj Z✝)) = f ≫ f' ≫ ↑(e Z✝ (F_obj Z✝)) (𝟙 (F_obj Z✝))
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
F_obj : C → D
e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
he : ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y), ↑(e X Y') (h ≫ g) = ↑(e X Y) h ≫ G.map g
X' X : C
Y : D
f : X' ⟶ X
g : X ⟶ G.obj Y
⊢ ↑(e X' Y).symm (f ≫ g) = (leftAdjointOfEquiv e he).map f ≫ ↑(e X Y).symm g
[PROOFSTEP]
have := @he' C _ D _ G F_obj e he
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
F_obj : C → D
e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
he : ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y), ↑(e X Y') (h ≫ g) = ↑(e X Y) h ≫ G.map g
X' X : C
Y : D
f : X' ⟶ X
g : X ⟶ G.obj Y
this : ∀ {X : C} {Y Y' : D} (f : X ⟶ G.obj Y) (g : Y ⟶ Y'), ↑(e X Y').symm (f ≫ G.map g) = ↑(e X Y).symm f ≫ g
⊢ ↑(e X' Y).symm (f ≫ g) = (leftAdjointOfEquiv e he).map f ≫ ↑(e X Y).symm g
[PROOFSTEP]
erw [← this, ← Equiv.apply_eq_iff_eq (e X' Y)]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
F_obj : C → D
e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
he : ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y), ↑(e X Y') (h ≫ g) = ↑(e X Y) h ≫ G.map g
X' X : C
Y : D
f : X' ⟶ X
g : X ⟶ G.obj Y
this : ∀ {X : C} {Y Y' : D} (f : X ⟶ G.obj Y) (g : Y ⟶ Y'), ↑(e X Y').symm (f ≫ G.map g) = ↑(e X Y).symm f ≫ g
⊢ ↑(e X' Y) (↑(e X' Y).symm (f ≫ g)) =
    ↑(e X' Y)
      (↑(e X' Y).symm ((f ≫ ↑(e X ((fun X => F_obj X) X)) (𝟙 ((fun X => F_obj X) X))) ≫ G.map (↑(e X Y).symm g)))
[PROOFSTEP]
simp [(he X' (F_obj X) Y (e X Y |>.symm g) (leftAdjointOfEquiv e he |>.map f)).symm]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
F_obj : C → D
e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
he : ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y), ↑(e X Y') (h ≫ g) = ↑(e X Y) h ≫ G.map g
X' X : C
Y : D
f : X' ⟶ X
g : X ⟶ G.obj Y
this : ∀ {X : C} {Y Y' : D} (f : X ⟶ G.obj Y) (g : Y ⟶ Y'), ↑(e X Y').symm (f ≫ G.map g) = ↑(e X Y).symm f ≫ g
⊢ f ≫ g = f ≫ ↑(e X (F_obj X)) (𝟙 (F_obj X)) ≫ G.map (↑(e X Y).symm g)
[PROOFSTEP]
congr
[GOAL]
case e_a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
F_obj : C → D
e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
he : ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y), ↑(e X Y') (h ≫ g) = ↑(e X Y) h ≫ G.map g
X' X : C
Y : D
f : X' ⟶ X
g : X ⟶ G.obj Y
this : ∀ {X : C} {Y Y' : D} (f : X ⟶ G.obj Y) (g : Y ⟶ Y'), ↑(e X Y').symm (f ≫ G.map g) = ↑(e X Y).symm f ≫ g
⊢ g = ↑(e X (F_obj X)) (𝟙 (F_obj X)) ≫ G.map (↑(e X Y).symm g)
[PROOFSTEP]
rw [← he]
[GOAL]
case e_a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
F_obj : C → D
e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
he : ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y), ↑(e X Y') (h ≫ g) = ↑(e X Y) h ≫ G.map g
X' X : C
Y : D
f : X' ⟶ X
g : X ⟶ G.obj Y
this : ∀ {X : C} {Y Y' : D} (f : X ⟶ G.obj Y) (g : Y ⟶ Y'), ↑(e X Y').symm (f ≫ G.map g) = ↑(e X Y).symm f ≫ g
⊢ g = ↑(e X Y) (𝟙 (F_obj X) ≫ ↑(e X Y).symm g)
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
G_obj : D → C
e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)
he : ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y), ↑(e X' Y) (F.map f ≫ g) = f ≫ ↑(e X Y) g
X' X : C
Y : D
f : X' ⟶ X
g : X ⟶ G_obj Y
⊢ F.map f ≫ ↑(e X Y).symm g = ↑(e X' Y).symm (f ≫ g)
[PROOFSTEP]
intros
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
G_obj : D → C
e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)
he : ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y), ↑(e X' Y) (F.map f ≫ g) = f ≫ ↑(e X Y) g
X' X : C
Y : D
f : X' ⟶ X
g : X ⟶ G_obj Y
⊢ F.map f ≫ ↑(e X Y).symm g = ↑(e X' Y).symm (f ≫ g)
[PROOFSTEP]
rw [Equiv.eq_symm_apply, he]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
G_obj : D → C
e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)
he : ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y), ↑(e X' Y) (F.map f ≫ g) = f ≫ ↑(e X Y) g
X' X : C
Y : D
f : X' ⟶ X
g : X ⟶ G_obj Y
⊢ f ≫ ↑(e X Y) (↑(e X Y).symm g) = f ≫ g
[PROOFSTEP]
simp
  -- #align category_theory.adjunction.he' category_theory.adjunction.he'
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
G_obj : D → C
e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)
he : ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y), ↑(e X' Y) (F.map f ≫ g) = f ≫ ↑(e X Y) g
Y Y' Y'' : D
g : Y ⟶ Y'
g' : Y' ⟶ Y''
⊢ { obj := G_obj, map := fun {Y Y'} g => ↑(e (G_obj Y) Y') (↑(e (G_obj Y) Y).symm (𝟙 (G_obj Y)) ≫ g) }.map (g ≫ g') =
    { obj := G_obj, map := fun {Y Y'} g => ↑(e (G_obj Y) Y') (↑(e (G_obj Y) Y).symm (𝟙 (G_obj Y)) ≫ g) }.map g ≫
      { obj := G_obj, map := fun {Y Y'} g => ↑(e (G_obj Y) Y') (↑(e (G_obj Y) Y).symm (𝟙 (G_obj Y)) ≫ g) }.map g'
[PROOFSTEP]
rw [← Equiv.eq_symm_apply, ← he'' e he, Equiv.symm_apply_apply]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
G_obj : D → C
e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)
he : ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y), ↑(e X' Y) (F.map f ≫ g) = f ≫ ↑(e X Y) g
Y Y' Y'' : D
g : Y ⟶ Y'
g' : Y' ⟶ Y''
⊢ ↑(e (G_obj Y) Y).symm (𝟙 (G_obj Y)) ≫ g ≫ g' =
    F.map ({ obj := G_obj, map := fun {Y Y'} g => ↑(e (G_obj Y) Y') (↑(e (G_obj Y) Y).symm (𝟙 (G_obj Y)) ≫ g) }.map g) ≫
      ↑(e (G_obj Y') Y').symm (𝟙 (G_obj Y')) ≫ g'
[PROOFSTEP]
conv =>
  rhs
  rw [← assoc, he'' e he, comp_id, Equiv.symm_apply_apply]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
G_obj : D → C
e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)
he : ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y), ↑(e X' Y) (F.map f ≫ g) = f ≫ ↑(e X Y) g
Y Y' Y'' : D
g : Y ⟶ Y'
g' : Y' ⟶ Y''
| ↑(e (G_obj Y) Y).symm (𝟙 (G_obj Y)) ≫ g ≫ g' =
    F.map ({ obj := G_obj, map := fun {Y Y'} g => ↑(e (G_obj Y) Y') (↑(e (G_obj Y) Y).symm (𝟙 (G_obj Y)) ≫ g) }.map g) ≫
      ↑(e (G_obj Y') Y').symm (𝟙 (G_obj Y')) ≫ g'
[PROOFSTEP]
  rhs
  rw [← assoc, he'' e he, comp_id, Equiv.symm_apply_apply]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
G_obj : D → C
e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)
he : ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y), ↑(e X' Y) (F.map f ≫ g) = f ≫ ↑(e X Y) g
Y Y' Y'' : D
g : Y ⟶ Y'
g' : Y' ⟶ Y''
| ↑(e (G_obj Y) Y).symm (𝟙 (G_obj Y)) ≫ g ≫ g' =
    F.map ({ obj := G_obj, map := fun {Y Y'} g => ↑(e (G_obj Y) Y') (↑(e (G_obj Y) Y).symm (𝟙 (G_obj Y)) ≫ g) }.map g) ≫
      ↑(e (G_obj Y') Y').symm (𝟙 (G_obj Y')) ≫ g'
[PROOFSTEP]
  rhs
  rw [← assoc, he'' e he, comp_id, Equiv.symm_apply_apply]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
G_obj : D → C
e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)
he : ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y), ↑(e X' Y) (F.map f ≫ g) = f ≫ ↑(e X Y) g
Y Y' Y'' : D
g : Y ⟶ Y'
g' : Y' ⟶ Y''
| ↑(e (G_obj Y) Y).symm (𝟙 (G_obj Y)) ≫ g ≫ g' =
    F.map ({ obj := G_obj, map := fun {Y Y'} g => ↑(e (G_obj Y) Y') (↑(e (G_obj Y) Y).symm (𝟙 (G_obj Y)) ≫ g) }.map g) ≫
      ↑(e (G_obj Y') Y').symm (𝟙 (G_obj Y')) ≫ g'
[PROOFSTEP]
rhs
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
G_obj : D → C
e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)
he : ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y), ↑(e X' Y) (F.map f ≫ g) = f ≫ ↑(e X Y) g
Y Y' Y'' : D
g : Y ⟶ Y'
g' : Y' ⟶ Y''
| F.map ({ obj := G_obj, map := fun {Y Y'} g => ↑(e (G_obj Y) Y') (↑(e (G_obj Y) Y).symm (𝟙 (G_obj Y)) ≫ g) }.map g) ≫
    ↑(e (G_obj Y') Y').symm (𝟙 (G_obj Y')) ≫ g'
[PROOFSTEP]
rw [← assoc, he'' e he, comp_id, Equiv.symm_apply_apply]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
G_obj : D → C
e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)
he : ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y), ↑(e X' Y) (F.map f ≫ g) = f ≫ ↑(e X Y) g
Y Y' Y'' : D
g : Y ⟶ Y'
g' : Y' ⟶ Y''
⊢ ↑(e (G_obj Y) Y).symm (𝟙 (G_obj Y)) ≫ g ≫ g' = (↑(e (G_obj Y) Y).symm (𝟙 (G_obj Y)) ≫ g) ≫ g'
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
G_obj : D → C
e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)
he : ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y), ↑(e X' Y) (F.map f ≫ g) = f ≫ ↑(e X Y) g
⊢ ∀ {X' X : C} {Y : D} (f : X' ⟶ X) (g : X ⟶ (rightAdjointOfEquiv e he).obj Y),
    ↑(e X' Y).symm (f ≫ g) = F.map f ≫ ↑(e X Y).symm g
[PROOFSTEP]
intro X X' Y f g
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
G_obj : D → C
e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)
he : ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y), ↑(e X' Y) (F.map f ≫ g) = f ≫ ↑(e X Y) g
X X' : C
Y : D
f : X ⟶ X'
g : X' ⟶ (rightAdjointOfEquiv e he).obj Y
⊢ ↑(e X Y).symm (f ≫ g) = F.map f ≫ ↑(e X' Y).symm g
[PROOFSTEP]
rw [Equiv.symm_apply_eq]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
G_obj : D → C
e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)
he : ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y), ↑(e X' Y) (F.map f ≫ g) = f ≫ ↑(e X Y) g
X X' : C
Y : D
f : X ⟶ X'
g : X' ⟶ (rightAdjointOfEquiv e he).obj Y
⊢ f ≫ g = ↑(e X Y) (F.map f ≫ ↑(e X' Y).symm g)
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
G_obj : D → C
e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)
he : ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y), ↑(e X' Y) (F.map f ≫ g) = f ≫ ↑(e X Y) g
X X' : C
Y : D
f : X ⟶ X'
g : X' ⟶ (rightAdjointOfEquiv e he).obj Y
⊢ f ≫ g = ↑(e X Y) (F.map f ≫ ↑(e X' Y).symm g)
[PROOFSTEP]
rw [he]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
G_obj : D → C
e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)
he : ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y), ↑(e X' Y) (F.map f ≫ g) = f ≫ ↑(e X Y) g
X X' : C
Y : D
f : X ⟶ X'
g : X' ⟶ (rightAdjointOfEquiv e he).obj Y
⊢ f ≫ g = f ≫ ↑(e X' Y) (↑(e X' Y).symm g)
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
G_obj : D → C
e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)
he : ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y), ↑(e X' Y) (F.map f ≫ g) = f ≫ ↑(e X Y) g
⊢ ∀ {X : C} {Y Y' : D} (f : F.obj X ⟶ Y) (g : Y ⟶ Y'), ↑(e X Y') (f ≫ g) = ↑(e X Y) f ≫ (rightAdjointOfEquiv e he).map g
[PROOFSTEP]
intro X Y Y' g h
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
G_obj : D → C
e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y)
he : ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y), ↑(e X' Y) (F.map f ≫ g) = f ≫ ↑(e X Y) g
X : C
Y Y' : D
g : F.obj X ⟶ Y
h : Y ⟶ Y'
⊢ ↑(e X Y') (g ≫ h) = ↑(e X Y) g ≫ (rightAdjointOfEquiv e he).map h
[PROOFSTEP]
erw [← he, Equiv.apply_eq_iff_eq, ← assoc, he'' e he, comp_id, Equiv.symm_apply_apply]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
⊢ whiskerRight (unit e) e.functor ≫
      (Functor.associator e.functor e.inverse e.functor).hom ≫ whiskerLeft e.functor (counit e) =
    NatTrans.id (𝟭 C ⋙ e.functor)
[PROOFSTEP]
ext
[GOAL]
case w.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
x✝ : C
⊢ NatTrans.app
      (whiskerRight (unit e) e.functor ≫
        (Functor.associator e.functor e.inverse e.functor).hom ≫ whiskerLeft e.functor (counit e))
      x✝ =
    NatTrans.app (NatTrans.id (𝟭 C ⋙ e.functor)) x✝
[PROOFSTEP]
dsimp
[GOAL]
case w.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
x✝ : C
⊢ e.functor.map (NatTrans.app (unit e) x✝) ≫
      𝟙 (e.functor.obj (e.inverse.obj (e.functor.obj x✝))) ≫ NatTrans.app (counit e) (e.functor.obj x✝) =
    𝟙 (e.functor.obj x✝)
[PROOFSTEP]
simp only [id_comp]
[GOAL]
case w.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
x✝ : C
⊢ e.functor.map (NatTrans.app (unit e) x✝) ≫ NatTrans.app (counit e) (e.functor.obj x✝) = 𝟙 (e.functor.obj x✝)
[PROOFSTEP]
exact e.functor_unit_comp _
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
⊢ whiskerLeft e.inverse (unit e) ≫
      (Functor.associator e.inverse e.functor e.inverse).inv ≫ whiskerRight (counit e) e.inverse =
    NatTrans.id (e.inverse ⋙ 𝟭 C)
[PROOFSTEP]
ext
[GOAL]
case w.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
x✝ : D
⊢ NatTrans.app
      (whiskerLeft e.inverse (unit e) ≫
        (Functor.associator e.inverse e.functor e.inverse).inv ≫ whiskerRight (counit e) e.inverse)
      x✝ =
    NatTrans.app (NatTrans.id (e.inverse ⋙ 𝟭 C)) x✝
[PROOFSTEP]
dsimp
[GOAL]
case w.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
x✝ : D
⊢ NatTrans.app (unit e) (e.inverse.obj x✝) ≫
      𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj x✝))) ≫ e.inverse.map (NatTrans.app (counit e) x✝) =
    𝟙 (e.inverse.obj x✝)
[PROOFSTEP]
simp only [id_comp]
[GOAL]
case w.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
x✝ : D
⊢ NatTrans.app (unit e) (e.inverse.obj x✝) ≫ e.inverse.map (NatTrans.app (counit e) x✝) = 𝟙 (e.inverse.obj x✝)
[PROOFSTEP]
exact e.unit_inverse_comp _


[GOAL]
β : Type v
inst✝¹ : NormedRing β
hn : IsAbsoluteValue norm
f : CauSeq β norm
inst✝ : IsComplete β norm
⊢ ∀ (s : Set β), IsOpen s → lim f ∈ s → ↑f ⁻¹' s ∈ atTop
[PROOFSTEP]
intro s os lfs
[GOAL]
β : Type v
inst✝¹ : NormedRing β
hn : IsAbsoluteValue norm
f : CauSeq β norm
inst✝ : IsComplete β norm
s : Set β
os : IsOpen s
lfs : lim f ∈ s
⊢ ↑f ⁻¹' s ∈ atTop
[PROOFSTEP]
suffices ∃ a : ℕ, ∀ b : ℕ, b ≥ a → f b ∈ s by simpa using this
[GOAL]
β : Type v
inst✝¹ : NormedRing β
hn : IsAbsoluteValue norm
f : CauSeq β norm
inst✝ : IsComplete β norm
s : Set β
os : IsOpen s
lfs : lim f ∈ s
this : ∃ a, ∀ (b : ℕ), b ≥ a → ↑f b ∈ s
⊢ ↑f ⁻¹' s ∈ atTop
[PROOFSTEP]
simpa using this
[GOAL]
β : Type v
inst✝¹ : NormedRing β
hn : IsAbsoluteValue norm
f : CauSeq β norm
inst✝ : IsComplete β norm
s : Set β
os : IsOpen s
lfs : lim f ∈ s
⊢ ∃ a, ∀ (b : ℕ), b ≥ a → ↑f b ∈ s
[PROOFSTEP]
rcases Metric.isOpen_iff.1 os _ lfs with ⟨ε, ⟨hε, hεs⟩⟩
[GOAL]
case intro.intro
β : Type v
inst✝¹ : NormedRing β
hn : IsAbsoluteValue norm
f : CauSeq β norm
inst✝ : IsComplete β norm
s : Set β
os : IsOpen s
lfs : lim f ∈ s
ε : ℝ
hε : ε > 0
hεs : Metric.ball (lim f) ε ⊆ s
⊢ ∃ a, ∀ (b : ℕ), b ≥ a → ↑f b ∈ s
[PROOFSTEP]
cases' Setoid.symm (CauSeq.equiv_lim f) _ hε with N hN
[GOAL]
case intro.intro.intro
β : Type v
inst✝¹ : NormedRing β
hn : IsAbsoluteValue norm
f : CauSeq β norm
inst✝ : IsComplete β norm
s : Set β
os : IsOpen s
lfs : lim f ∈ s
ε : ℝ
hε : ε > 0
hεs : Metric.ball (lim f) ε ⊆ s
N : ℕ
hN : ∀ (j : ℕ), j ≥ N → ‖↑(const norm (lim f) - f) j‖ < ε
⊢ ∃ a, ∀ (b : ℕ), b ≥ a → ↑f b ∈ s
[PROOFSTEP]
exists N
[GOAL]
case intro.intro.intro
β : Type v
inst✝¹ : NormedRing β
hn : IsAbsoluteValue norm
f : CauSeq β norm
inst✝ : IsComplete β norm
s : Set β
os : IsOpen s
lfs : lim f ∈ s
ε : ℝ
hε : ε > 0
hεs : Metric.ball (lim f) ε ⊆ s
N : ℕ
hN : ∀ (j : ℕ), j ≥ N → ‖↑(const norm (lim f) - f) j‖ < ε
⊢ ∀ (b : ℕ), b ≥ N → ↑f b ∈ s
[PROOFSTEP]
intro b hb
[GOAL]
case intro.intro.intro
β : Type v
inst✝¹ : NormedRing β
hn : IsAbsoluteValue norm
f : CauSeq β norm
inst✝ : IsComplete β norm
s : Set β
os : IsOpen s
lfs : lim f ∈ s
ε : ℝ
hε : ε > 0
hεs : Metric.ball (lim f) ε ⊆ s
N : ℕ
hN : ∀ (j : ℕ), j ≥ N → ‖↑(const norm (lim f) - f) j‖ < ε
b : ℕ
hb : b ≥ N
⊢ ↑f b ∈ s
[PROOFSTEP]
apply hεs
[GOAL]
case intro.intro.intro.a
β : Type v
inst✝¹ : NormedRing β
hn : IsAbsoluteValue norm
f : CauSeq β norm
inst✝ : IsComplete β norm
s : Set β
os : IsOpen s
lfs : lim f ∈ s
ε : ℝ
hε : ε > 0
hεs : Metric.ball (lim f) ε ⊆ s
N : ℕ
hN : ∀ (j : ℕ), j ≥ N → ‖↑(const norm (lim f) - f) j‖ < ε
b : ℕ
hb : b ≥ N
⊢ ↑f b ∈ Metric.ball (lim f) ε
[PROOFSTEP]
dsimp [Metric.ball]
[GOAL]
case intro.intro.intro.a
β : Type v
inst✝¹ : NormedRing β
hn : IsAbsoluteValue norm
f : CauSeq β norm
inst✝ : IsComplete β norm
s : Set β
os : IsOpen s
lfs : lim f ∈ s
ε : ℝ
hε : ε > 0
hεs : Metric.ball (lim f) ε ⊆ s
N : ℕ
hN : ∀ (j : ℕ), j ≥ N → ‖↑(const norm (lim f) - f) j‖ < ε
b : ℕ
hb : b ≥ N
⊢ dist (↑f b) (lim f) < ε
[PROOFSTEP]
rw [dist_comm, dist_eq_norm]
[GOAL]
case intro.intro.intro.a
β : Type v
inst✝¹ : NormedRing β
hn : IsAbsoluteValue norm
f : CauSeq β norm
inst✝ : IsComplete β norm
s : Set β
os : IsOpen s
lfs : lim f ∈ s
ε : ℝ
hε : ε > 0
hεs : Metric.ball (lim f) ε ⊆ s
N : ℕ
hN : ∀ (j : ℕ), j ≥ N → ‖↑(const norm (lim f) - f) j‖ < ε
b : ℕ
hb : b ≥ N
⊢ ‖lim f - ↑f b‖ < ε
[PROOFSTEP]
solve_by_elim
[GOAL]
β : Type v
inst✝ : NormedField β
f : ℕ → β
hf : CauchySeq f
⊢ IsCauSeq norm f
[PROOFSTEP]
cases' cauchy_iff.1 hf with hf1 hf2
[GOAL]
case intro
β : Type v
inst✝ : NormedField β
f : ℕ → β
hf : CauchySeq f
hf1 : NeBot (map f atTop)
hf2 : ∀ (s : Set (β × β)), s ∈ uniformity β → ∃ t, t ∈ map f atTop ∧ t ×ˢ t ⊆ s
⊢ IsCauSeq norm f
[PROOFSTEP]
intro ε hε
[GOAL]
case intro
β : Type v
inst✝ : NormedField β
f : ℕ → β
hf : CauchySeq f
hf1 : NeBot (map f atTop)
hf2 : ∀ (s : Set (β × β)), s ∈ uniformity β → ∃ t, t ∈ map f atTop ∧ t ×ˢ t ⊆ s
ε : ℝ
hε : ε > 0
⊢ ∃ i, ∀ (j : ℕ), j ≥ i → ‖f j - f i‖ < ε
[PROOFSTEP]
rcases hf2 {x | dist x.1 x.2 < ε} (dist_mem_uniformity hε) with ⟨t, ⟨ht, htsub⟩⟩
[GOAL]
case intro.intro.intro
β : Type v
inst✝ : NormedField β
f : ℕ → β
hf : CauchySeq f
hf1 : NeBot (map f atTop)
hf2 : ∀ (s : Set (β × β)), s ∈ uniformity β → ∃ t, t ∈ map f atTop ∧ t ×ˢ t ⊆ s
ε : ℝ
hε : ε > 0
t : Set β
ht : t ∈ map f atTop
htsub : t ×ˢ t ⊆ {x | dist x.fst x.snd < ε}
⊢ ∃ i, ∀ (j : ℕ), j ≥ i → ‖f j - f i‖ < ε
[PROOFSTEP]
simp at ht
[GOAL]
case intro.intro.intro
β : Type v
inst✝ : NormedField β
f : ℕ → β
hf : CauchySeq f
hf1 : NeBot (map f atTop)
hf2 : ∀ (s : Set (β × β)), s ∈ uniformity β → ∃ t, t ∈ map f atTop ∧ t ×ˢ t ⊆ s
ε : ℝ
hε : ε > 0
t : Set β
htsub : t ×ˢ t ⊆ {x | dist x.fst x.snd < ε}
ht : ∃ a, ∀ (b : ℕ), a ≤ b → f b ∈ t
⊢ ∃ i, ∀ (j : ℕ), j ≥ i → ‖f j - f i‖ < ε
[PROOFSTEP]
cases' ht with N hN
[GOAL]
case intro.intro.intro.intro
β : Type v
inst✝ : NormedField β
f : ℕ → β
hf : CauchySeq f
hf1 : NeBot (map f atTop)
hf2 : ∀ (s : Set (β × β)), s ∈ uniformity β → ∃ t, t ∈ map f atTop ∧ t ×ˢ t ⊆ s
ε : ℝ
hε : ε > 0
t : Set β
htsub : t ×ˢ t ⊆ {x | dist x.fst x.snd < ε}
N : ℕ
hN : ∀ (b : ℕ), N ≤ b → f b ∈ t
⊢ ∃ i, ∀ (j : ℕ), j ≥ i → ‖f j - f i‖ < ε
[PROOFSTEP]
exists N
[GOAL]
case intro.intro.intro.intro
β : Type v
inst✝ : NormedField β
f : ℕ → β
hf : CauchySeq f
hf1 : NeBot (map f atTop)
hf2 : ∀ (s : Set (β × β)), s ∈ uniformity β → ∃ t, t ∈ map f atTop ∧ t ×ˢ t ⊆ s
ε : ℝ
hε : ε > 0
t : Set β
htsub : t ×ˢ t ⊆ {x | dist x.fst x.snd < ε}
N : ℕ
hN : ∀ (b : ℕ), N ≤ b → f b ∈ t
⊢ ∀ (j : ℕ), j ≥ N → ‖f j - f N‖ < ε
[PROOFSTEP]
intro j hj
[GOAL]
case intro.intro.intro.intro
β : Type v
inst✝ : NormedField β
f : ℕ → β
hf : CauchySeq f
hf1 : NeBot (map f atTop)
hf2 : ∀ (s : Set (β × β)), s ∈ uniformity β → ∃ t, t ∈ map f atTop ∧ t ×ˢ t ⊆ s
ε : ℝ
hε : ε > 0
t : Set β
htsub : t ×ˢ t ⊆ {x | dist x.fst x.snd < ε}
N : ℕ
hN : ∀ (b : ℕ), N ≤ b → f b ∈ t
j : ℕ
hj : j ≥ N
⊢ ‖f j - f N‖ < ε
[PROOFSTEP]
rw [← dist_eq_norm]
[GOAL]
case intro.intro.intro.intro
β : Type v
inst✝ : NormedField β
f : ℕ → β
hf : CauchySeq f
hf1 : NeBot (map f atTop)
hf2 : ∀ (s : Set (β × β)), s ∈ uniformity β → ∃ t, t ∈ map f atTop ∧ t ×ˢ t ⊆ s
ε : ℝ
hε : ε > 0
t : Set β
htsub : t ×ˢ t ⊆ {x | dist x.fst x.snd < ε}
N : ℕ
hN : ∀ (b : ℕ), N ≤ b → f b ∈ t
j : ℕ
hj : j ≥ N
⊢ dist (f j) (f N) < ε
[PROOFSTEP]
apply @htsub (f j, f N)
[GOAL]
case intro.intro.intro.intro
β : Type v
inst✝ : NormedField β
f : ℕ → β
hf : CauchySeq f
hf1 : NeBot (map f atTop)
hf2 : ∀ (s : Set (β × β)), s ∈ uniformity β → ∃ t, t ∈ map f atTop ∧ t ×ˢ t ⊆ s
ε : ℝ
hε : ε > 0
t : Set β
htsub : t ×ˢ t ⊆ {x | dist x.fst x.snd < ε}
N : ℕ
hN : ∀ (b : ℕ), N ≤ b → f b ∈ t
j : ℕ
hj : j ≥ N
⊢ (f j, f N) ∈ t ×ˢ t
[PROOFSTEP]
apply Set.mk_mem_prod
[GOAL]
case intro.intro.intro.intro.ha
β : Type v
inst✝ : NormedField β
f : ℕ → β
hf : CauchySeq f
hf1 : NeBot (map f atTop)
hf2 : ∀ (s : Set (β × β)), s ∈ uniformity β → ∃ t, t ∈ map f atTop ∧ t ×ˢ t ⊆ s
ε : ℝ
hε : ε > 0
t : Set β
htsub : t ×ˢ t ⊆ {x | dist x.fst x.snd < ε}
N : ℕ
hN : ∀ (b : ℕ), N ≤ b → f b ∈ t
j : ℕ
hj : j ≥ N
⊢ f j ∈ t
[PROOFSTEP]
solve_by_elim [le_refl]
[GOAL]
case intro.intro.intro.intro.hb
β : Type v
inst✝ : NormedField β
f : ℕ → β
hf : CauchySeq f
hf1 : NeBot (map f atTop)
hf2 : ∀ (s : Set (β × β)), s ∈ uniformity β → ∃ t, t ∈ map f atTop ∧ t ×ˢ t ⊆ s
ε : ℝ
hε : ε > 0
t : Set β
htsub : t ×ˢ t ⊆ {x | dist x.fst x.snd < ε}
N : ℕ
hN : ∀ (b : ℕ), N ≤ b → f b ∈ t
j : ℕ
hj : j ≥ N
⊢ f N ∈ t
[PROOFSTEP]
solve_by_elim [le_refl]
[GOAL]
β : Type v
inst✝ : NormedField β
f : CauSeq β norm
⊢ CauchySeq ↑f
[PROOFSTEP]
refine' cauchy_iff.2 ⟨by infer_instance, fun s hs => _⟩
[GOAL]
β : Type v
inst✝ : NormedField β
f : CauSeq β norm
⊢ NeBot (map (↑f) atTop)
[PROOFSTEP]
infer_instance
[GOAL]
β : Type v
inst✝ : NormedField β
f : CauSeq β norm
s : Set (β × β)
hs : s ∈ uniformity β
⊢ ∃ t, t ∈ map (↑f) atTop ∧ t ×ˢ t ⊆ s
[PROOFSTEP]
rcases mem_uniformity_dist.1 hs with ⟨ε, ⟨hε, hεs⟩⟩
[GOAL]
case intro.intro
β : Type v
inst✝ : NormedField β
f : CauSeq β norm
s : Set (β × β)
hs : s ∈ uniformity β
ε : ℝ
hε : ε > 0
hεs : ∀ {a b : β}, dist a b < ε → (a, b) ∈ s
⊢ ∃ t, t ∈ map (↑f) atTop ∧ t ×ˢ t ⊆ s
[PROOFSTEP]
cases' CauSeq.cauchy₂ f hε with N hN
[GOAL]
case intro.intro.intro
β : Type v
inst✝ : NormedField β
f : CauSeq β norm
s : Set (β × β)
hs : s ∈ uniformity β
ε : ℝ
hε : ε > 0
hεs : ∀ {a b : β}, dist a b < ε → (a, b) ∈ s
N : ℕ
hN : ∀ (j : ℕ), j ≥ N → ∀ (k : ℕ), k ≥ N → ‖↑f j - ↑f k‖ < ε
⊢ ∃ t, t ∈ map (↑f) atTop ∧ t ×ˢ t ⊆ s
[PROOFSTEP]
exists {n | n ≥ N}.image f
[GOAL]
case intro.intro.intro
β : Type v
inst✝ : NormedField β
f : CauSeq β norm
s : Set (β × β)
hs : s ∈ uniformity β
ε : ℝ
hε : ε > 0
hεs : ∀ {a b : β}, dist a b < ε → (a, b) ∈ s
N : ℕ
hN : ∀ (j : ℕ), j ≥ N → ∀ (k : ℕ), k ≥ N → ‖↑f j - ↑f k‖ < ε
⊢ ↑f '' {n | n ≥ N} ∈ map (↑f) atTop ∧ (↑f '' {n | n ≥ N}) ×ˢ (↑f '' {n | n ≥ N}) ⊆ s
[PROOFSTEP]
simp only [exists_prop, mem_atTop_sets, mem_map, mem_image, ge_iff_le, mem_setOf_eq]
[GOAL]
case intro.intro.intro
β : Type v
inst✝ : NormedField β
f : CauSeq β norm
s : Set (β × β)
hs : s ∈ uniformity β
ε : ℝ
hε : ε > 0
hεs : ∀ {a b : β}, dist a b < ε → (a, b) ∈ s
N : ℕ
hN : ∀ (j : ℕ), j ≥ N → ∀ (k : ℕ), k ≥ N → ‖↑f j - ↑f k‖ < ε
⊢ (∃ a, ∀ (b : ℕ), a ≤ b → b ∈ ↑f ⁻¹' (↑f '' {n | N ≤ n})) ∧ (↑f '' {n | N ≤ n}) ×ˢ (↑f '' {n | N ≤ n}) ⊆ s
[PROOFSTEP]
constructor
[GOAL]
case intro.intro.intro.left
β : Type v
inst✝ : NormedField β
f : CauSeq β norm
s : Set (β × β)
hs : s ∈ uniformity β
ε : ℝ
hε : ε > 0
hεs : ∀ {a b : β}, dist a b < ε → (a, b) ∈ s
N : ℕ
hN : ∀ (j : ℕ), j ≥ N → ∀ (k : ℕ), k ≥ N → ‖↑f j - ↑f k‖ < ε
⊢ ∃ a, ∀ (b : ℕ), a ≤ b → b ∈ ↑f ⁻¹' (↑f '' {n | N ≤ n})
[PROOFSTEP]
exists N
[GOAL]
case intro.intro.intro.left
β : Type v
inst✝ : NormedField β
f : CauSeq β norm
s : Set (β × β)
hs : s ∈ uniformity β
ε : ℝ
hε : ε > 0
hεs : ∀ {a b : β}, dist a b < ε → (a, b) ∈ s
N : ℕ
hN : ∀ (j : ℕ), j ≥ N → ∀ (k : ℕ), k ≥ N → ‖↑f j - ↑f k‖ < ε
⊢ ∀ (b : ℕ), N ≤ b → b ∈ ↑f ⁻¹' (↑f '' {n | N ≤ n})
[PROOFSTEP]
intro b hb
[GOAL]
case intro.intro.intro.left
β : Type v
inst✝ : NormedField β
f : CauSeq β norm
s : Set (β × β)
hs : s ∈ uniformity β
ε : ℝ
hε : ε > 0
hεs : ∀ {a b : β}, dist a b < ε → (a, b) ∈ s
N : ℕ
hN : ∀ (j : ℕ), j ≥ N → ∀ (k : ℕ), k ≥ N → ‖↑f j - ↑f k‖ < ε
b : ℕ
hb : N ≤ b
⊢ b ∈ ↑f ⁻¹' (↑f '' {n | N ≤ n})
[PROOFSTEP]
exists b
[GOAL]
case intro.intro.intro.right
β : Type v
inst✝ : NormedField β
f : CauSeq β norm
s : Set (β × β)
hs : s ∈ uniformity β
ε : ℝ
hε : ε > 0
hεs : ∀ {a b : β}, dist a b < ε → (a, b) ∈ s
N : ℕ
hN : ∀ (j : ℕ), j ≥ N → ∀ (k : ℕ), k ≥ N → ‖↑f j - ↑f k‖ < ε
⊢ (↑f '' {n | N ≤ n}) ×ˢ (↑f '' {n | N ≤ n}) ⊆ s
[PROOFSTEP]
rintro ⟨a, b⟩ ⟨⟨a', ⟨ha'1, ha'2⟩⟩, ⟨b', ⟨hb'1, hb'2⟩⟩⟩
[GOAL]
case intro.intro.intro.right.mk.intro.intro.intro.intro.intro
β : Type v
inst✝ : NormedField β
f : CauSeq β norm
s : Set (β × β)
hs : s ∈ uniformity β
ε : ℝ
hε : ε > 0
hεs : ∀ {a b : β}, dist a b < ε → (a, b) ∈ s
N : ℕ
hN : ∀ (j : ℕ), j ≥ N → ∀ (k : ℕ), k ≥ N → ‖↑f j - ↑f k‖ < ε
a b : β
a' : ℕ
ha'1 : a' ∈ {n | N ≤ n}
ha'2 : ↑f a' = (a, b).fst
b' : ℕ
hb'1 : b' ∈ {n | N ≤ n}
hb'2 : ↑f b' = (a, b).snd
⊢ (a, b) ∈ s
[PROOFSTEP]
dsimp at ha'1 ha'2 hb'1 hb'2
[GOAL]
case intro.intro.intro.right.mk.intro.intro.intro.intro.intro
β : Type v
inst✝ : NormedField β
f : CauSeq β norm
s : Set (β × β)
hs : s ∈ uniformity β
ε : ℝ
hε : ε > 0
hεs : ∀ {a b : β}, dist a b < ε → (a, b) ∈ s
N : ℕ
hN : ∀ (j : ℕ), j ≥ N → ∀ (k : ℕ), k ≥ N → ‖↑f j - ↑f k‖ < ε
a b : β
a' : ℕ
ha'1 : N ≤ a'
ha'2 : ↑f a' = a
b' : ℕ
hb'1 : N ≤ b'
hb'2 : ↑f b' = b
⊢ (a, b) ∈ s
[PROOFSTEP]
rw [← ha'2, ← hb'2]
[GOAL]
case intro.intro.intro.right.mk.intro.intro.intro.intro.intro
β : Type v
inst✝ : NormedField β
f : CauSeq β norm
s : Set (β × β)
hs : s ∈ uniformity β
ε : ℝ
hε : ε > 0
hεs : ∀ {a b : β}, dist a b < ε → (a, b) ∈ s
N : ℕ
hN : ∀ (j : ℕ), j ≥ N → ∀ (k : ℕ), k ≥ N → ‖↑f j - ↑f k‖ < ε
a b : β
a' : ℕ
ha'1 : N ≤ a'
ha'2 : ↑f a' = a
b' : ℕ
hb'1 : N ≤ b'
hb'2 : ↑f b' = b
⊢ (↑f a', ↑f b') ∈ s
[PROOFSTEP]
apply hεs
[GOAL]
case intro.intro.intro.right.mk.intro.intro.intro.intro.intro.a
β : Type v
inst✝ : NormedField β
f : CauSeq β norm
s : Set (β × β)
hs : s ∈ uniformity β
ε : ℝ
hε : ε > 0
hεs : ∀ {a b : β}, dist a b < ε → (a, b) ∈ s
N : ℕ
hN : ∀ (j : ℕ), j ≥ N → ∀ (k : ℕ), k ≥ N → ‖↑f j - ↑f k‖ < ε
a b : β
a' : ℕ
ha'1 : N ≤ a'
ha'2 : ↑f a' = a
b' : ℕ
hb'1 : N ≤ b'
hb'2 : ↑f b' = b
⊢ dist (↑f a') (↑f b') < ε
[PROOFSTEP]
rw [dist_eq_norm]
[GOAL]
case intro.intro.intro.right.mk.intro.intro.intro.intro.intro.a
β : Type v
inst✝ : NormedField β
f : CauSeq β norm
s : Set (β × β)
hs : s ∈ uniformity β
ε : ℝ
hε : ε > 0
hεs : ∀ {a b : β}, dist a b < ε → (a, b) ∈ s
N : ℕ
hN : ∀ (j : ℕ), j ≥ N → ∀ (k : ℕ), k ≥ N → ‖↑f j - ↑f k‖ < ε
a b : β
a' : ℕ
ha'1 : N ≤ a'
ha'2 : ↑f a' = a
b' : ℕ
hb'1 : N ≤ b'
hb'2 : ↑f b' = b
⊢ ‖↑f a' - ↑f b'‖ < ε
[PROOFSTEP]
apply hN
[GOAL]
case intro.intro.intro.right.mk.intro.intro.intro.intro.intro.a.x
β : Type v
inst✝ : NormedField β
f : CauSeq β norm
s : Set (β × β)
hs : s ∈ uniformity β
ε : ℝ
hε : ε > 0
hεs : ∀ {a b : β}, dist a b < ε → (a, b) ∈ s
N : ℕ
hN : ∀ (j : ℕ), j ≥ N → ∀ (k : ℕ), k ≥ N → ‖↑f j - ↑f k‖ < ε
a b : β
a' : ℕ
ha'1 : N ≤ a'
ha'2 : ↑f a' = a
b' : ℕ
hb'1 : N ≤ b'
hb'2 : ↑f b' = b
⊢ a' ≥ N
[PROOFSTEP]
assumption
[GOAL]
case intro.intro.intro.right.mk.intro.intro.intro.intro.intro.a.x
β : Type v
inst✝ : NormedField β
f : CauSeq β norm
s : Set (β × β)
hs : s ∈ uniformity β
ε : ℝ
hε : ε > 0
hεs : ∀ {a b : β}, dist a b < ε → (a, b) ∈ s
N : ℕ
hN : ∀ (j : ℕ), j ≥ N → ∀ (k : ℕ), k ≥ N → ‖↑f j - ↑f k‖ < ε
a b : β
a' : ℕ
ha'1 : N ≤ a'
ha'2 : ↑f a' = a
b' : ℕ
hb'1 : N ≤ b'
hb'2 : ↑f b' = b
⊢ b' ≥ N
[PROOFSTEP]
assumption
[GOAL]
β : Type v
inst✝¹ : NormedField β
inst✝ : CauSeq.IsComplete β norm
⊢ CompleteSpace β
[PROOFSTEP]
apply complete_of_cauchySeq_tendsto
[GOAL]
case a
β : Type v
inst✝¹ : NormedField β
inst✝ : CauSeq.IsComplete β norm
⊢ ∀ (u : ℕ → β), CauchySeq u → ∃ a, Tendsto u atTop (𝓝 a)
[PROOFSTEP]
intro u hu
[GOAL]
case a
β : Type v
inst✝¹ : NormedField β
inst✝ : CauSeq.IsComplete β norm
u : ℕ → β
hu : CauchySeq u
⊢ ∃ a, Tendsto u atTop (𝓝 a)
[PROOFSTEP]
have C : IsCauSeq norm u := isCauSeq_iff_cauchySeq.2 hu
[GOAL]
case a
β : Type v
inst✝¹ : NormedField β
inst✝ : CauSeq.IsComplete β norm
u : ℕ → β
hu : CauchySeq u
C : IsCauSeq norm u
⊢ ∃ a, Tendsto u atTop (𝓝 a)
[PROOFSTEP]
exists CauSeq.lim ⟨u, C⟩
[GOAL]
case a
β : Type v
inst✝¹ : NormedField β
inst✝ : CauSeq.IsComplete β norm
u : ℕ → β
hu : CauchySeq u
C : IsCauSeq norm u
⊢ Tendsto u atTop (𝓝 (CauSeq.lim { val := u, property := C }))
[PROOFSTEP]
rw [Metric.tendsto_atTop]
[GOAL]
case a
β : Type v
inst✝¹ : NormedField β
inst✝ : CauSeq.IsComplete β norm
u : ℕ → β
hu : CauchySeq u
C : IsCauSeq norm u
⊢ ∀ (ε : ℝ), ε > 0 → ∃ N, ∀ (n : ℕ), n ≥ N → dist (u n) (CauSeq.lim { val := u, property := C }) < ε
[PROOFSTEP]
intro ε εpos
[GOAL]
case a
β : Type v
inst✝¹ : NormedField β
inst✝ : CauSeq.IsComplete β norm
u : ℕ → β
hu : CauchySeq u
C : IsCauSeq norm u
ε : ℝ
εpos : ε > 0
⊢ ∃ N, ∀ (n : ℕ), n ≥ N → dist (u n) (CauSeq.lim { val := u, property := C }) < ε
[PROOFSTEP]
cases' (CauSeq.equiv_lim ⟨u, C⟩) _ εpos with N hN
[GOAL]
case a.intro
β : Type v
inst✝¹ : NormedField β
inst✝ : CauSeq.IsComplete β norm
u : ℕ → β
hu : CauchySeq u
C : IsCauSeq norm u
ε : ℝ
εpos : ε > 0
N : ℕ
hN :
  ∀ (j : ℕ), j ≥ N → ‖↑({ val := u, property := C } - CauSeq.const norm (CauSeq.lim { val := u, property := C })) j‖ < ε
⊢ ∃ N, ∀ (n : ℕ), n ≥ N → dist (u n) (CauSeq.lim { val := u, property := C }) < ε
[PROOFSTEP]
exists N
[GOAL]
case a.intro
β : Type v
inst✝¹ : NormedField β
inst✝ : CauSeq.IsComplete β norm
u : ℕ → β
hu : CauchySeq u
C : IsCauSeq norm u
ε : ℝ
εpos : ε > 0
N : ℕ
hN :
  ∀ (j : ℕ), j ≥ N → ‖↑({ val := u, property := C } - CauSeq.const norm (CauSeq.lim { val := u, property := C })) j‖ < ε
⊢ ∀ (n : ℕ), n ≥ N → dist (u n) (CauSeq.lim { val := u, property := C }) < ε
[PROOFSTEP]
simpa [dist_eq_norm] using hN


[GOAL]
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapc : ∠ a p c = π
hbpd : ∠ b p d = π
⊢ dist a b * dist c d + dist b c * dist d a = dist a c * dist b d
[PROOFSTEP]
have h' : Cospherical ({ a, c, b, d } : Set P) := by rwa [Set.insert_comm c b { d }]
[GOAL]
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapc : ∠ a p c = π
hbpd : ∠ b p d = π
⊢ Cospherical {a, c, b, d}
[PROOFSTEP]
rwa [Set.insert_comm c b { d }]
[GOAL]
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapc : ∠ a p c = π
hbpd : ∠ b p d = π
h' : Cospherical {a, c, b, d}
⊢ dist a b * dist c d + dist b c * dist d a = dist a c * dist b d
[PROOFSTEP]
have hmul := mul_dist_eq_mul_dist_of_cospherical_of_angle_eq_pi h' hapc hbpd
[GOAL]
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapc : ∠ a p c = π
hbpd : ∠ b p d = π
h' : Cospherical {a, c, b, d}
hmul : dist a p * dist c p = dist b p * dist d p
⊢ dist a b * dist c d + dist b c * dist d a = dist a c * dist b d
[PROOFSTEP]
have hbp := left_dist_ne_zero_of_angle_eq_pi hbpd
[GOAL]
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapc : ∠ a p c = π
hbpd : ∠ b p d = π
h' : Cospherical {a, c, b, d}
hmul : dist a p * dist c p = dist b p * dist d p
hbp : dist b p ≠ 0
⊢ dist a b * dist c d + dist b c * dist d a = dist a c * dist b d
[PROOFSTEP]
have h₁ : dist c d = dist c p / dist b p * dist a b :=
  by
  rw [dist_mul_of_eq_angle_of_dist_mul b p a c p d, dist_comm a b]
  · rw [angle_eq_angle_of_angle_eq_pi_of_angle_eq_pi hbpd hapc, angle_comm]
  all_goals field_simp [mul_comm, hmul]
[GOAL]
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapc : ∠ a p c = π
hbpd : ∠ b p d = π
h' : Cospherical {a, c, b, d}
hmul : dist a p * dist c p = dist b p * dist d p
hbp : dist b p ≠ 0
⊢ dist c d = dist c p / dist b p * dist a b
[PROOFSTEP]
rw [dist_mul_of_eq_angle_of_dist_mul b p a c p d, dist_comm a b]
[GOAL]
case h
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapc : ∠ a p c = π
hbpd : ∠ b p d = π
h' : Cospherical {a, c, b, d}
hmul : dist a p * dist c p = dist b p * dist d p
hbp : dist b p ≠ 0
⊢ ∠ c p d = ∠ b p a
[PROOFSTEP]
rw [angle_eq_angle_of_angle_eq_pi_of_angle_eq_pi hbpd hapc, angle_comm]
[GOAL]
case hab
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapc : ∠ a p c = π
hbpd : ∠ b p d = π
h' : Cospherical {a, c, b, d}
hmul : dist a p * dist c p = dist b p * dist d p
hbp : dist b p ≠ 0
⊢ dist c p = dist c p / dist b p * dist b p
case hcb
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapc : ∠ a p c = π
hbpd : ∠ b p d = π
h' : Cospherical {a, c, b, d}
hmul : dist a p * dist c p = dist b p * dist d p
hbp : dist b p ≠ 0
⊢ dist d p = dist c p / dist b p * dist a p
[PROOFSTEP]
all_goals field_simp [mul_comm, hmul]
[GOAL]
case hab
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapc : ∠ a p c = π
hbpd : ∠ b p d = π
h' : Cospherical {a, c, b, d}
hmul : dist a p * dist c p = dist b p * dist d p
hbp : dist b p ≠ 0
⊢ dist c p = dist c p / dist b p * dist b p
[PROOFSTEP]
field_simp [mul_comm, hmul]
[GOAL]
case hcb
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapc : ∠ a p c = π
hbpd : ∠ b p d = π
h' : Cospherical {a, c, b, d}
hmul : dist a p * dist c p = dist b p * dist d p
hbp : dist b p ≠ 0
⊢ dist d p = dist c p / dist b p * dist a p
[PROOFSTEP]
field_simp [mul_comm, hmul]
[GOAL]
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapc : ∠ a p c = π
hbpd : ∠ b p d = π
h' : Cospherical {a, c, b, d}
hmul : dist a p * dist c p = dist b p * dist d p
hbp : dist b p ≠ 0
h₁ : dist c d = dist c p / dist b p * dist a b
⊢ dist a b * dist c d + dist b c * dist d a = dist a c * dist b d
[PROOFSTEP]
have h₂ : dist d a = dist a p / dist b p * dist b c :=
  by
  rw [dist_mul_of_eq_angle_of_dist_mul c p b d p a, dist_comm c b]
  · rwa [angle_comm, angle_eq_angle_of_angle_eq_pi_of_angle_eq_pi]; rwa [angle_comm]
  all_goals field_simp [mul_comm, hmul]
[GOAL]
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapc : ∠ a p c = π
hbpd : ∠ b p d = π
h' : Cospherical {a, c, b, d}
hmul : dist a p * dist c p = dist b p * dist d p
hbp : dist b p ≠ 0
h₁ : dist c d = dist c p / dist b p * dist a b
⊢ dist d a = dist a p / dist b p * dist b c
[PROOFSTEP]
rw [dist_mul_of_eq_angle_of_dist_mul c p b d p a, dist_comm c b]
[GOAL]
case h
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapc : ∠ a p c = π
hbpd : ∠ b p d = π
h' : Cospherical {a, c, b, d}
hmul : dist a p * dist c p = dist b p * dist d p
hbp : dist b p ≠ 0
h₁ : dist c d = dist c p / dist b p * dist a b
⊢ ∠ d p a = ∠ c p b
[PROOFSTEP]
rwa [angle_comm, angle_eq_angle_of_angle_eq_pi_of_angle_eq_pi]
[GOAL]
case h.hbpd
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapc : ∠ a p c = π
hbpd : ∠ b p d = π
h' : Cospherical {a, c, b, d}
hmul : dist a p * dist c p = dist b p * dist d p
hbp : dist b p ≠ 0
h₁ : dist c d = dist c p / dist b p * dist a b
⊢ ∠ d p b = π
[PROOFSTEP]
rwa [angle_comm]
[GOAL]
case hab
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapc : ∠ a p c = π
hbpd : ∠ b p d = π
h' : Cospherical {a, c, b, d}
hmul : dist a p * dist c p = dist b p * dist d p
hbp : dist b p ≠ 0
h₁ : dist c d = dist c p / dist b p * dist a b
⊢ dist d p = dist a p / dist b p * dist c p
case hcb
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapc : ∠ a p c = π
hbpd : ∠ b p d = π
h' : Cospherical {a, c, b, d}
hmul : dist a p * dist c p = dist b p * dist d p
hbp : dist b p ≠ 0
h₁ : dist c d = dist c p / dist b p * dist a b
⊢ dist a p = dist a p / dist b p * dist b p
[PROOFSTEP]
all_goals field_simp [mul_comm, hmul]
[GOAL]
case hab
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapc : ∠ a p c = π
hbpd : ∠ b p d = π
h' : Cospherical {a, c, b, d}
hmul : dist a p * dist c p = dist b p * dist d p
hbp : dist b p ≠ 0
h₁ : dist c d = dist c p / dist b p * dist a b
⊢ dist d p = dist a p / dist b p * dist c p
[PROOFSTEP]
field_simp [mul_comm, hmul]
[GOAL]
case hcb
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapc : ∠ a p c = π
hbpd : ∠ b p d = π
h' : Cospherical {a, c, b, d}
hmul : dist a p * dist c p = dist b p * dist d p
hbp : dist b p ≠ 0
h₁ : dist c d = dist c p / dist b p * dist a b
⊢ dist a p = dist a p / dist b p * dist b p
[PROOFSTEP]
field_simp [mul_comm, hmul]
[GOAL]
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapc : ∠ a p c = π
hbpd : ∠ b p d = π
h' : Cospherical {a, c, b, d}
hmul : dist a p * dist c p = dist b p * dist d p
hbp : dist b p ≠ 0
h₁ : dist c d = dist c p / dist b p * dist a b
h₂ : dist d a = dist a p / dist b p * dist b c
⊢ dist a b * dist c d + dist b c * dist d a = dist a c * dist b d
[PROOFSTEP]
have h₃ : dist d p = dist a p * dist c p / dist b p := by field_simp [mul_comm, hmul]
[GOAL]
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapc : ∠ a p c = π
hbpd : ∠ b p d = π
h' : Cospherical {a, c, b, d}
hmul : dist a p * dist c p = dist b p * dist d p
hbp : dist b p ≠ 0
h₁ : dist c d = dist c p / dist b p * dist a b
h₂ : dist d a = dist a p / dist b p * dist b c
⊢ dist d p = dist a p * dist c p / dist b p
[PROOFSTEP]
field_simp [mul_comm, hmul]
[GOAL]
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapc : ∠ a p c = π
hbpd : ∠ b p d = π
h' : Cospherical {a, c, b, d}
hmul : dist a p * dist c p = dist b p * dist d p
hbp : dist b p ≠ 0
h₁ : dist c d = dist c p / dist b p * dist a b
h₂ : dist d a = dist a p / dist b p * dist b c
h₃ : dist d p = dist a p * dist c p / dist b p
⊢ dist a b * dist c d + dist b c * dist d a = dist a c * dist b d
[PROOFSTEP]
have h₄ : ∀ x y : ℝ, x * (y * x) = x * x * y := fun x y => by rw [mul_left_comm, mul_comm]
[GOAL]
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapc : ∠ a p c = π
hbpd : ∠ b p d = π
h' : Cospherical {a, c, b, d}
hmul : dist a p * dist c p = dist b p * dist d p
hbp : dist b p ≠ 0
h₁ : dist c d = dist c p / dist b p * dist a b
h₂ : dist d a = dist a p / dist b p * dist b c
h₃ : dist d p = dist a p * dist c p / dist b p
x y : ℝ
⊢ x * (y * x) = x * x * y
[PROOFSTEP]
rw [mul_left_comm, mul_comm]
[GOAL]
V : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_2
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapc : ∠ a p c = π
hbpd : ∠ b p d = π
h' : Cospherical {a, c, b, d}
hmul : dist a p * dist c p = dist b p * dist d p
hbp : dist b p ≠ 0
h₁ : dist c d = dist c p / dist b p * dist a b
h₂ : dist d a = dist a p / dist b p * dist b c
h₃ : dist d p = dist a p * dist c p / dist b p
h₄ : ∀ (x y : ℝ), x * (y * x) = x * x * y
⊢ dist a b * dist c d + dist b c * dist d a = dist a c * dist b d
[PROOFSTEP]
field_simp [h₁, h₂, dist_eq_add_dist_of_angle_eq_pi hbpd, h₃, hbp, dist_comm a b, h₄, ← sq,
  dist_sq_mul_dist_add_dist_sq_mul_dist b, hapc]


[GOAL]
R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
h : m ≤ n
⊢ ↑(n - m) + ↑m = ↑n
[PROOFSTEP]
rw [← cast_add, Nat.sub_add_cancel h]
[GOAL]
R : Type u
inst✝ : AddGroupWithOne R
h : 0 < 0
⊢ ↑(0 - 1) = ↑0 - 1
[PROOFSTEP]
cases h
[GOAL]
R : Type u
inst✝ : AddGroupWithOne R
n : ℕ
x✝ : 0 < n + 1
⊢ ↑(n + 1 - 1) = ↑(n + 1) - 1
[PROOFSTEP]
rw [cast_succ, add_sub_cancel]
[GOAL]
R : Type u
inst✝ : AddGroupWithOne R
n : ℕ
x✝ : 0 < n + 1
⊢ ↑(n + 1 - 1) = ↑n
[PROOFSTEP]
rfl
[GOAL]
R : Type u
inst✝¹ : AddGroupWithOne R
n : ℕ
inst✝ : AtLeastTwo n
⊢ ↑(OfNat.ofNat n) = OfNat.ofNat n
[PROOFSTEP]
simpa only [OfNat.ofNat] using AddGroupWithOne.intCast_ofNat (R := R) n
[GOAL]
R : Type u
inst✝ : AddGroupWithOne R
⊢ ↑1 = 1
[PROOFSTEP]
erw [cast_ofNat, Nat.cast_one]
[GOAL]
R : Type u
inst✝ : AddGroupWithOne R
⊢ ↑(-↑0) = -↑↑0
[PROOFSTEP]
erw [cast_zero, neg_zero]
[GOAL]
R : Type u
inst✝ : AddGroupWithOne R
n : ℕ
⊢ ↑(-↑(n + 1)) = -↑↑(n + 1)
[PROOFSTEP]
erw [cast_ofNat, cast_negSucc]
[GOAL]
R : Type u
inst✝ : AddGroupWithOne R
n : ℕ
⊢ ↑(- -[n+1]) = -↑-[n+1]
[PROOFSTEP]
erw [cast_ofNat, cast_negSucc, neg_neg]
[GOAL]
R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
⊢ ↑(subNatNat m n) = ↑m - ↑n
[PROOFSTEP]
unfold subNatNat
[GOAL]
R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
⊢ ↑(match n - m with
      | 0 => ofNat (m - n)
      | succ k => -[k+1]) =
    ↑m - ↑n
[PROOFSTEP]
cases e : n - m
[GOAL]
case zero
R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
e : n - m = zero
⊢ ↑(match zero with
      | 0 => ofNat (m - n)
      | succ k => -[k+1]) =
    ↑m - ↑n
[PROOFSTEP]
simp only [ofNat_eq_coe]
[GOAL]
case zero
R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
e : n - m = zero
⊢ ↑↑(m - n) = ↑m - ↑n
[PROOFSTEP]
simp [e, Nat.le_of_sub_eq_zero e]
[GOAL]
case succ
R : Type u
inst✝ : AddGroupWithOne R
m n n✝ : ℕ
e : n - m = succ n✝
⊢ ↑(match succ n✝ with
      | 0 => ofNat (m - n)
      | succ k => -[k+1]) =
    ↑m - ↑n
[PROOFSTEP]
rw [cast_negSucc, Nat.add_one, ← e, Nat.cast_sub <| _root_.le_of_lt <| Nat.lt_of_sub_eq_succ e, neg_sub]
[GOAL]
R : Type u
inst✝ : AddGroupWithOne R
n : ℕ
⊢ ↑(negOfNat n) = -↑n
[PROOFSTEP]
simp [Int.cast_neg, negOfNat_eq]
[GOAL]
R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
⊢ ↑(↑m + ↑n) = ↑↑m + ↑↑n
[PROOFSTEP]
simp [← Int.ofNat_add, Nat.cast_add]
[GOAL]
R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
⊢ ↑(↑m + -[n+1]) = ↑↑m + ↑-[n+1]
[PROOFSTEP]
erw [cast_subNatNat, cast_ofNat, cast_negSucc, sub_eq_add_neg]
[GOAL]
R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
⊢ ↑(-[m+1] + ↑n) = ↑-[m+1] + ↑↑n
[PROOFSTEP]
erw [cast_subNatNat, cast_ofNat, cast_negSucc, sub_eq_iff_eq_add, add_assoc, eq_neg_add_iff_add_eq, ← Nat.cast_add, ←
  Nat.cast_add, Nat.add_comm]
[GOAL]
R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
⊢ ↑-[m + n + 1+1] = ↑-[m+1] + ↑-[n+1]
[PROOFSTEP]
rw [cast_negSucc, cast_negSucc, cast_negSucc, ← neg_add_rev, ← Nat.cast_add, Nat.add_right_comm m n 1, Nat.add_assoc,
  Nat.add_comm]
[GOAL]
R : Type u
inst✝ : AddGroupWithOne R
m n : ℤ
⊢ ↑(m - n) = ↑m - ↑n
[PROOFSTEP]
simp [Int.sub_eq_add_neg, sub_eq_add_neg, Int.cast_neg, Int.cast_add]
[GOAL]
R : Type u
inst✝ : AddGroupWithOne R
n : ℤ
⊢ ↑(bit1 n) = bit1 ↑n
[PROOFSTEP]
rw [bit1, Int.cast_add, Int.cast_one, cast_bit0]
[GOAL]
R : Type u
inst✝ : AddGroupWithOne R
n : ℤ
⊢ bit0 ↑n + 1 = bit1 ↑n
[PROOFSTEP]
rfl
[GOAL]
R : Type u
inst✝ : AddGroupWithOne R
⊢ ↑↑2 = ↑2
[PROOFSTEP]
rw [cast_ofNat, Nat.cast_ofNat]
[GOAL]
R : Type u
inst✝ : AddGroupWithOne R
⊢ ↑↑3 = ↑3
[PROOFSTEP]
rw [cast_ofNat, Nat.cast_ofNat]
[GOAL]
R : Type u
inst✝ : AddGroupWithOne R
⊢ ↑↑4 = ↑4
[PROOFSTEP]
rw [cast_ofNat, Nat.cast_ofNat]