Theorem: CategoryTheory.Functor.pi_ext
File: Mathlib/CategoryTheory/Pi/Basic.lean

tactic: apply Functor.ext
state_before: I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category (C i)
D : I → Type u₁
inst✝¹ : (i : I) → Category (D i)
A : Type u₁
inst✝ : Category A
f f' : A ⥤ ((i : I) → C i)
h : ∀ (i : I), f ⋙ Pi.eval C i = f' ⋙ Pi.eval C i
⊢ f = f'

tactic: rotate_left
state_before: case h_map
I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category (C i)
D : I → Type u₁
inst✝¹ : (i : I) → Category (D i)
A : Type u₁
inst✝ : Category A
f f' : A ⥤ ((i : I) → C i)
h : ∀ (i : I), f ⋙ Pi.eval C i = f' ⋙ Pi.eval C i
⊢ autoParam
    (∀ (X Y : A) (f_1 : X ⟶ Y),
      f.map f_1 = eqToHom (_ : ?F.obj X = ?G.obj X) ≫ f'.map f_1 ≫ eqToHom (_ : f'.obj Y = f.obj Y))
    _auto✝

case h_obj
I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category (C i)
D : I → Type u₁
inst✝¹ : (i : I) → Category (D i)
A : Type u₁
inst✝ : Category A
f f' : A ⥤ ((i : I) → C i)
h : ∀ (i : I), f ⋙ Pi.eval C i = f' ⋙ Pi.eval C i
⊢ ∀ (X : A), f.obj X = f'.obj X

tactic: intro X
state_before: case h_obj
I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category (C i)
D : I → Type u₁
inst✝¹ : (i : I) → Category (D i)
A : Type u₁
inst✝ : Category A
f f' : A ⥤ ((i : I) → C i)
h : ∀ (i : I), f ⋙ Pi.eval C i = f' ⋙ Pi.eval C i
⊢ ∀ (X : A), f.obj X = f'.obj X

tactic: ext i
state_before: case h_obj
I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category (C i)
D : I → Type u₁
inst✝¹ : (i : I) → Category (D i)
A : Type u₁
inst✝ : Category A
f f' : A ⥤ ((i : I) → C i)
h : ∀ (i : I), f ⋙ Pi.eval C i = f' ⋙ Pi.eval C i
X : A
⊢ f.obj X = f'.obj X

tactic: specialize h i
state_before: case h_obj.h
I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category (C i)
D : I → Type u₁
inst✝¹ : (i : I) → Category (D i)
A : Type u₁
inst✝ : Category A
f f' : A ⥤ ((i : I) → C i)
h : ∀ (i : I), f ⋙ Pi.eval C i = f' ⋙ Pi.eval C i
X : A
i : I
⊢ f.obj X i = f'.obj X i

tactic: have := congr_obj h X
state_before: case h_obj.h
I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category (C i)
D : I → Type u₁
inst✝¹ : (i : I) → Category (D i)
A : Type u₁
inst✝ : Category A
f f' : A ⥤ ((i : I) → C i)
X : A
i : I
h : f ⋙ Pi.eval C i = f' ⋙ Pi.eval C i
⊢ f.obj X i = f'.obj X i

tactic: simpa
state_before: case h_obj.h
I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category (C i)
D : I → Type u₁
inst✝¹ : (i : I) → Category (D i)
A : Type u₁
inst✝ : Category A
f f' : A ⥤ ((i : I) → C i)
X : A
i : I
h : f ⋙ Pi.eval C i = f' ⋙ Pi.eval C i
this : (f ⋙ Pi.eval C i).obj X = (f' ⋙ Pi.eval C i).obj X
⊢ f.obj X i = f'.obj X i

tactic: intro X Y g
state_before: case h_map
I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category (C i)
D : I → Type u₁
inst✝¹ : (i : I) → Category (D i)
A : Type u₁
inst✝ : Category A
f f' : A ⥤ ((i : I) → C i)
h : ∀ (i : I), f ⋙ Pi.eval C i = f' ⋙ Pi.eval C i
⊢ autoParam
    (∀ (X Y : A) (f_1 : X ⟶ Y),
      f.map f_1 = eqToHom (_ : f.obj X = f'.obj X) ≫ f'.map f_1 ≫ eqToHom (_ : f'.obj Y = f.obj Y))
    _auto✝

tactic: dsimp
state_before: case h_map
I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category (C i)
D : I → Type u₁
inst✝¹ : (i : I) → Category (D i)
A : Type u₁
inst✝ : Category A
f f' : A ⥤ ((i : I) → C i)
h : ∀ (i : I), f ⋙ Pi.eval C i = f' ⋙ Pi.eval C i
X Y : A
g : X ⟶ Y
⊢ f.map g = eqToHom (_ : f.obj X = f'.obj X) ≫ f'.map g ≫ eqToHom (_ : f'.obj Y = f.obj Y)

tactic: funext i
state_before: case h_map
I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category (C i)
D : I → Type u₁
inst✝¹ : (i : I) → Category (D i)
A : Type u₁
inst✝ : Category A
f f' : A ⥤ ((i : I) → C i)
h : ∀ (i : I), f ⋙ Pi.eval C i = f' ⋙ Pi.eval C i
X Y : A
g : X ⟶ Y
⊢ f.map g = eqToHom (_ : f.obj X = f'.obj X) ≫ f'.map g ≫ eqToHom (_ : f'.obj Y = f.obj Y)

tactic: specialize h i
state_before: case h_map.h
I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category (C i)
D : I → Type u₁
inst✝¹ : (i : I) → Category (D i)
A : Type u₁
inst✝ : Category A
f f' : A ⥤ ((i : I) → C i)
h : ∀ (i : I), f ⋙ Pi.eval C i = f' ⋙ Pi.eval C i
X Y : A
g : X ⟶ Y
i : I
⊢ f.map g i = (eqToHom (_ : f.obj X = f'.obj X) ≫ f'.map g ≫ eqToHom (_ : f'.obj Y = f.obj Y)) i

tactic: have := congr_hom h g
state_before: case h_map.h
I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category (C i)
D : I → Type u₁
inst✝¹ : (i : I) → Category (D i)
A : Type u₁
inst✝ : Category A
f f' : A ⥤ ((i : I) → C i)
h✝ : ∀ (i : I), f ⋙ Pi.eval C i = f' ⋙ Pi.eval C i
X Y : A
g : X ⟶ Y
i : I
h : f ⋙ Pi.eval C i = f' ⋙ Pi.eval C i
⊢ f.map g i = (eqToHom (_ : f.obj X = f'.obj X) ≫ f'.map g ≫ eqToHom (_ : f'.obj Y = f.obj Y)) i

tactic: simpa
state_before: case h_map.h
I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category (C i)
D : I → Type u₁
inst✝¹ : (i : I) → Category (D i)
A : Type u₁
inst✝ : Category A
f f' : A ⥤ ((i : I) → C i)
h✝ : ∀ (i : I), f ⋙ Pi.eval C i = f' ⋙ Pi.eval C i
X Y : A
g : X ⟶ Y
i : I
h : f ⋙ Pi.eval C i = f' ⋙ Pi.eval C i
this :
  (f ⋙ Pi.eval C i).map g =
    eqToHom (_ : (f ⋙ Pi.eval C i).obj X = (f' ⋙ Pi.eval C i).obj X) ≫
      (f' ⋙ Pi.eval C i).map g ≫ eqToHom (_ : (f' ⋙ Pi.eval C i).obj Y = (f ⋙ Pi.eval C i).obj Y)
⊢ f.map g i = (eqToHom (_ : f.obj X = f'.obj X) ≫ f'.map g ≫ eqToHom (_ : f'.obj Y = f.obj Y)) i