Theorem: CategoryTheory.IsCofiltered.of_cone_nonempty
File: Mathlib/CategoryTheory/Filtered/Basic.lean

tactic: have : Nonempty C := by
  obtain ⟨c⟩ := h (Functor.empty _)
  exact ⟨c.pt⟩
state_before: C : Type u
inst✝ : Category.{v, u} C
h : ∀ {J : Type w} [inst : SmallCategory J] [inst_1 : FinCategory J] (F : J ⥤ C), Nonempty (Cone F)
⊢ IsCofiltered C
state_after: C : Type u
inst✝ : Category.{v, u} C
h : ∀ {J : Type w} [inst : SmallCategory J] [inst_1 : FinCategory J] (F : J ⥤ C), Nonempty (Cone F)
this : Nonempty C
⊢ IsCofiltered C

tactic: apply IsCofiltered.mk
state_before: C : Type u
inst✝ : Category.{v, u} C
h : ∀ {J : Type w} [inst : SmallCategory J] [inst_1 : FinCategory J] (F : J ⥤ C), Nonempty (Cone F)
this✝ : Nonempty C
this : IsCofilteredOrEmpty C
⊢ IsCofiltered C
state_after: no goals

tactic: obtain ⟨c⟩ := h (Functor.empty _)
state_before: C : Type u
inst✝ : Category.{v, u} C
h : ∀ {J : Type w} [inst : SmallCategory J] [inst_1 : FinCategory J] (F : J ⥤ C), Nonempty (Cone F)
⊢ Nonempty C
state_after: case intro
C : Type u
inst✝ : Category.{v, u} C
h : ∀ {J : Type w} [inst : SmallCategory J] [inst_1 : FinCategory J] (F : J ⥤ C), Nonempty (Cone F)
c : Cone (Functor.empty C)
⊢ Nonempty C

tactic: exact ⟨c.pt⟩
state_before: case intro
C : Type u
inst✝ : Category.{v, u} C
h : ∀ {J : Type w} [inst : SmallCategory J] [inst_1 : FinCategory J] (F : J ⥤ C), Nonempty (Cone F)
c : Cone (Functor.empty C)
⊢ Nonempty C
state_after: no goals

tactic: refine ⟨?_, ?_⟩
state_before: C : Type u
inst✝ : Category.{v, u} C
h : ∀ {J : Type w} [inst : SmallCategory J] [inst_1 : FinCategory J] (F : J ⥤ C), Nonempty (Cone F)
this : Nonempty C
⊢ IsCofilteredOrEmpty C
state_after: case refine_1
C : Type u
inst✝ : Category.{v, u} C
h : ∀ {J : Type w} [inst : SmallCategory J] [inst_1 : FinCategory J] (F : J ⥤ C), Nonempty (Cone F)
this : Nonempty C
⊢ ∀ (X Y : C), ∃ W x x, True

case refine_2
C : Type u
inst✝ : Category.{v, u} C
h : ∀ {J : Type w} [inst : SmallCategory J] [inst_1 : FinCategory J] (F : J ⥤ C), Nonempty (Cone F)
this : Nonempty C
⊢ ∀ ⦃X Y : C⦄ (f g : X ⟶ Y), ∃ W h, h ≫ f = h ≫ g

tactic: intros X Y
state_before: case refine_1
C : Type u
inst✝ : Category.{v, u} C
h : ∀ {J : Type w} [inst : SmallCategory J] [inst_1 : FinCategory J] (F : J ⥤ C), Nonempty (Cone F)
this : Nonempty C
⊢ ∀ (X Y : C), ∃ W x x, True
state_after: case refine_1
C : Type u
inst✝ : Category.{v, u} C
h : ∀ {J : Type w} [inst : SmallCategory J] [inst_1 : FinCategory J] (F : J ⥤ C), Nonempty (Cone F)
this : Nonempty C
X Y : C
⊢ ∃ W x x, True

tactic: obtain ⟨c⟩ := h (ULiftHom.down ⋙ ULift.downFunctor ⋙ pair X Y)
state_before: case refine_1
C : Type u
inst✝ : Category.{v, u} C
h : ∀ {J : Type w} [inst : SmallCategory J] [inst_1 : FinCategory J] (F : J ⥤ C), Nonempty (Cone F)
this : Nonempty C
X Y : C
⊢ ∃ W x x, True
state_after: case refine_1.intro
C : Type u
inst✝ : Category.{v, u} C
h : ∀ {J : Type w} [inst : SmallCategory J] [inst_1 : FinCategory J] (F : J ⥤ C), Nonempty (Cone F)
this : Nonempty C
X Y : C
c : Cone (ULiftHom.down ⋙ ULift.downFunctor ⋙ pair X Y)
⊢ ∃ W x x, True

tactic: exact ⟨c.pt, c.π.app ⟨⟨WalkingPair.left⟩⟩, c.π.app ⟨⟨WalkingPair.right⟩⟩, trivial⟩
state_before: case refine_1.intro
C : Type u
inst✝ : Category.{v, u} C
h : ∀ {J : Type w} [inst : SmallCategory J] [inst_1 : FinCategory J] (F : J ⥤ C), Nonempty (Cone F)
this : Nonempty C
X Y : C
c : Cone (ULiftHom.down ⋙ ULift.downFunctor ⋙ pair X Y)
⊢ ∃ W x x, True
state_after: no goals

tactic: intros X Y f g
state_before: case refine_2
C : Type u
inst✝ : Category.{v, u} C
h : ∀ {J : Type w} [inst : SmallCategory J] [inst_1 : FinCategory J] (F : J ⥤ C), Nonempty (Cone F)
this : Nonempty C
⊢ ∀ ⦃X Y : C⦄ (f g : X ⟶ Y), ∃ W h, h ≫ f = h ≫ g
state_after: case refine_2
C : Type u
inst✝ : Category.{v, u} C
h : ∀ {J : Type w} [inst : SmallCategory J] [inst_1 : FinCategory J] (F : J ⥤ C), Nonempty (Cone F)
this : Nonempty C
X Y : C
f g : X ⟶ Y
⊢ ∃ W h, h ≫ f = h ≫ g

tactic: obtain ⟨c⟩ := h (ULiftHom.down ⋙ ULift.downFunctor ⋙ parallelPair f g)
state_before: case refine_2
C : Type u
inst✝ : Category.{v, u} C
h : ∀ {J : Type w} [inst : SmallCategory J] [inst_1 : FinCategory J] (F : J ⥤ C), Nonempty (Cone F)
this : Nonempty C
X Y : C
f g : X ⟶ Y
⊢ ∃ W h, h ≫ f = h ≫ g
state_after: case refine_2.intro
C : Type u
inst✝ : Category.{v, u} C
h : ∀ {J : Type w} [inst : SmallCategory J] [inst_1 : FinCategory J] (F : J ⥤ C), Nonempty (Cone F)
this : Nonempty C
X Y : C
f g : X ⟶ Y
c : Cone (ULiftHom.down ⋙ ULift.downFunctor ⋙ parallelPair f g)
⊢ ∃ W h, h ≫ f = h ≫ g

tactic: refine ⟨c.pt, c.π.app ⟨WalkingParallelPair.zero⟩, ?_⟩
state_before: case refine_2.intro
C : Type u
inst✝ : Category.{v, u} C
h : ∀ {J : Type w} [inst : SmallCategory J] [inst_1 : FinCategory J] (F : J ⥤ C), Nonempty (Cone F)
this : Nonempty C
X Y : C
f g : X ⟶ Y
c : Cone (ULiftHom.down ⋙ ULift.downFunctor ⋙ parallelPair f g)
⊢ ∃ W h, h ≫ f = h ≫ g
state_after: case refine_2.intro
C : Type u
inst✝ : Category.{v, u} C
h : ∀ {J : Type w} [inst : SmallCategory J] [inst_1 : FinCategory J] (F : J ⥤ C), Nonempty (Cone F)
this : Nonempty C
X Y : C
f g : X ⟶ Y
c : Cone (ULiftHom.down ⋙ ULift.downFunctor ⋙ parallelPair f g)
⊢ c.π.app { down := WalkingParallelPair.zero } ≫ f = c.π.app { down := WalkingParallelPair.zero } ≫ g

tactic: have h₁ := c.π.naturality ⟨WalkingParallelPairHom.left⟩
state_before: case refine_2.intro
C : Type u
inst✝ : Category.{v, u} C
h : ∀ {J : Type w} [inst : SmallCategory J] [inst_1 : FinCategory J] (F : J ⥤ C), Nonempty (Cone F)
this : Nonempty C
X Y : C
f g : X ⟶ Y
c : Cone (ULiftHom.down ⋙ ULift.downFunctor ⋙ parallelPair f g)
⊢ c.π.app { down := WalkingParallelPair.zero } ≫ f = c.π.app { down := WalkingParallelPair.zero } ≫ g
state_after: case refine_2.intro
C : Type u
inst✝ : Category.{v, u} C
h : ∀ {J : Type w} [inst : SmallCategory J] [inst_1 : FinCategory J] (F : J ⥤ C), Nonempty (Cone F)
this : Nonempty C
X Y : C
f g : X ⟶ Y
c : Cone (ULiftHom.down ⋙ ULift.downFunctor ⋙ parallelPair f g)
h₁ :
  ((Functor.const (ULiftHom (ULift.{w, 0} WalkingParallelPair))).obj c.pt).map { down := WalkingParallelPairHom.left } ≫
      c.π.app { down := WalkingParallelPair.one } =
    c.π.app { down := WalkingParallelPair.zero } ≫
      (ULiftHom.down ⋙ ULift.downFunctor ⋙ parallelPair f g).map { down := WalkingParallelPairHom.left }
⊢ c.π.app { down := WalkingParallelPair.zero } ≫ f = c.π.app { down := WalkingParallelPair.zero } ≫ g

tactic: have h₂ := c.π.naturality ⟨WalkingParallelPairHom.right⟩
state_before: case refine_2.intro
C : Type u
inst✝ : Category.{v, u} C
h : ∀ {J : Type w} [inst : SmallCategory J] [inst_1 : FinCategory J] (F : J ⥤ C), Nonempty (Cone F)
this : Nonempty C
X Y : C
f g : X ⟶ Y
c : Cone (ULiftHom.down ⋙ ULift.downFunctor ⋙ parallelPair f g)
h₁ :
  ((Functor.const (ULiftHom (ULift.{w, 0} WalkingParallelPair))).obj c.pt).map { down := WalkingParallelPairHom.left } ≫
      c.π.app { down := WalkingParallelPair.one } =
    c.π.app { down := WalkingParallelPair.zero } ≫
      (ULiftHom.down ⋙ ULift.downFunctor ⋙ parallelPair f g).map { down := WalkingParallelPairHom.left }
⊢ c.π.app { down := WalkingParallelPair.zero } ≫ f = c.π.app { down := WalkingParallelPair.zero } ≫ g
state_after: case refine_2.intro
C : Type u
inst✝ : Category.{v, u} C
h : ∀ {J : Type w} [inst : SmallCategory J] [inst_1 : FinCategory J] (F : J ⥤ C), Nonempty (Cone F)
this : Nonempty C
X Y : C
f g : X ⟶ Y
c : Cone (ULiftHom.down ⋙ ULift.downFunctor ⋙ parallelPair f g)
h₁ :
  ((Functor.const (ULiftHom (ULift.{w, 0} WalkingParallelPair))).obj c.pt).map { down := WalkingParallelPairHom.left } ≫
      c.π.app { down := WalkingParallelPair.one } =
    c.π.app { down := WalkingParallelPair.zero } ≫
      (ULiftHom.down ⋙ ULift.downFunctor ⋙ parallelPair f g).map { down := WalkingParallelPairHom.left }
h₂ :
  ((Functor.const (ULiftHom (ULift.{w, 0} WalkingParallelPair))).obj c.pt).map
        { down := WalkingParallelPairHom.right } ≫
      c.π.app { down := WalkingParallelPair.one } =
    c.π.app { down := WalkingParallelPair.zero } ≫
      (ULiftHom.down ⋙ ULift.downFunctor ⋙ parallelPair f g).map { down := WalkingParallelPairHom.right }
⊢ c.π.app { down := WalkingParallelPair.zero } ≫ f = c.π.app { down := WalkingParallelPair.zero } ≫ g

tactic: simp_all
state_before: case refine_2.intro
C : Type u
inst✝ : Category.{v, u} C
h : ∀ {J : Type w} [inst : SmallCategory J] [inst_1 : FinCategory J] (F : J ⥤ C), Nonempty (Cone F)
this : Nonempty C
X Y : C
f g : X ⟶ Y
c : Cone (ULiftHom.down ⋙ ULift.downFunctor ⋙ parallelPair f g)
h₁ :
  ((Functor.const (ULiftHom (ULift.{w, 0} WalkingParallelPair))).obj c.pt).map { down := WalkingParallelPairHom.left } ≫
      c.π.app { down := WalkingParallelPair.one } =
    c.π.app { down := WalkingParallelPair.zero } ≫
      (ULiftHom.down ⋙ ULift.downFunctor ⋙ parallelPair f g).map { down := WalkingParallelPairHom.left }
h₂ :
  ((Functor.const (ULiftHom (ULift.{w, 0} WalkingParallelPair))).obj c.pt).map
        { down := WalkingParallelPairHom.right } ≫
      c.π.app { down := WalkingParallelPair.one } =
    c.π.app { down := WalkingParallelPair.zero } ≫
      (ULiftHom.down ⋙ ULift.downFunctor ⋙ parallelPair f g).map { down := WalkingParallelPairHom.right }
⊢ c.π.app { down := WalkingParallelPair.zero } ≫ f = c.π.app { down := WalkingParallelPair.zero } ≫ g
state_after: no goals