Theorem: CategoryTheory.regularTopology.parallelPair_pullback_initial
File: Mathlib/CategoryTheory/Sites/Coherent/RegularSheaves.lean

tactic: apply Limits.parallelPair_initial_mk
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
⊢ (parallelPair (Over.homMk c.fst ⋯).op (Over.homMk c.snd ⋯).op).Initial
state_after: case h₁
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
⊢ ∀ (Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryᵒᵖ),
    Nonempty ({ unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ } ⟶ Z)

case h₂
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
⊢ ∀ ⦃Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryᵒᵖ⦄
    (i j : { unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ } ⟶ Z),
    ∃ a, i = (Over.homMk c.fst ⋯).op ≫ a ∧ j = (Over.homMk c.snd ⋯).op ≫ a

tactic: intro ⟨Z⟩
state_before: case h₁
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
⊢ ∀ (Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryᵒᵖ),
    Nonempty ({ unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ } ⟶ Z)
state_after: case h₁
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
⊢ Nonempty ({ unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ } ⟶ { unop := Z })

tactic: obtain ⟨_, f, g, ⟨⟩, hh⟩ := Z.property
state_before: case h₁
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
⊢ Nonempty ({ unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ } ⟶ { unop := Z })
state_after: case h₁.intro.intro.intro.intro.mk
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
Y : C
i✝ : Unit
f : (𝟭 C).obj Z.obj.left ⟶ X
hh : f ≫ π = Z.obj.hom
⊢ Nonempty ({ unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ } ⟶ { unop := Z })

tactic: let X' : (Presieve.ofArrows (fun () ↦ X) (fun () ↦ π)).category :=
  Presieve.categoryMk _ π (ofArrows.mk ())
state_before: case h₁.intro.intro.intro.intro.mk
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
Y : C
i✝ : Unit
f : (𝟭 C).obj Z.obj.left ⟶ X
hh : f ≫ π = Z.obj.hom
⊢ Nonempty ({ unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ } ⟶ { unop := Z })
state_after: case h₁.intro.intro.intro.intro.mk
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
Y : C
i✝ : Unit
f : (𝟭 C).obj Z.obj.left ⟶ X
hh : f ≫ π = Z.obj.hom
X' : (ofArrows (fun x => X) fun x =>
    match x with
    | PUnit.unit => π).category :=
  (ofArrows (fun x => X) fun x =>
        match x with
        | PUnit.unit => π).categoryMk
    π ⋯
⊢ Nonempty ({ unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ } ⟶ { unop := Z })

tactic: let f' : Z.obj.left ⟶ X'.obj.left := f
state_before: case h₁.intro.intro.intro.intro.mk
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
Y : C
i✝ : Unit
f : (𝟭 C).obj Z.obj.left ⟶ X
hh : f ≫ π = Z.obj.hom
X' : (ofArrows (fun x => X) fun x =>
    match x with
    | PUnit.unit => π).category :=
  (ofArrows (fun x => X) fun x =>
        match x with
        | PUnit.unit => π).categoryMk
    π ⋯
⊢ Nonempty ({ unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ } ⟶ { unop := Z })
state_after: case h₁.intro.intro.intro.intro.mk
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
Y : C
i✝ : Unit
f : (𝟭 C).obj Z.obj.left ⟶ X
hh : f ≫ π = Z.obj.hom
X' : (ofArrows (fun x => X) fun x =>
    match x with
    | PUnit.unit => π).category :=
  (ofArrows (fun x => X) fun x =>
        match x with
        | PUnit.unit => π).categoryMk
    π ⋯
f' : Z.obj.left ⟶ X'.obj.left := f
⊢ Nonempty ({ unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ } ⟶ { unop := Z })

tactic: exact ⟨(Over.homMk f').op⟩
state_before: case h₁.intro.intro.intro.intro.mk
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
Y : C
i✝ : Unit
f : (𝟭 C).obj Z.obj.left ⟶ X
hh : f ≫ π = Z.obj.hom
X' : (ofArrows (fun x => X) fun x =>
    match x with
    | PUnit.unit => π).category :=
  (ofArrows (fun x => X) fun x =>
        match x with
        | PUnit.unit => π).categoryMk
    π ⋯
f' : Z.obj.left ⟶ X'.obj.left := f
⊢ Nonempty ({ unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ } ⟶ { unop := Z })
state_after: no goals

tactic: intro ⟨Z⟩ ⟨i⟩ ⟨j⟩
state_before: case h₂
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
⊢ ∀ ⦃Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryᵒᵖ⦄
    (i j : { unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ } ⟶ Z),
    ∃ a, i = (Over.homMk c.fst ⋯).op ≫ a ∧ j = (Over.homMk c.snd ⋯).op ≫ a
state_after: case h₂
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
i j : { unop := Z }.unop ⟶ { unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ }.unop
⊢ ∃ a, { unop := i } = (Over.homMk c.fst ⋯).op ≫ a ∧ { unop := j } = (Over.homMk c.snd ⋯).op ≫ a

tactic: let ij := PullbackCone.IsLimit.lift hc i.left j.left (by erw [i.w, j.w]; rfl)
state_before: case h₂
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
i j : { unop := Z }.unop ⟶ { unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ }.unop
⊢ ∃ a, { unop := i } = (Over.homMk c.fst ⋯).op ≫ a ∧ { unop := j } = (Over.homMk c.snd ⋯).op ≫ a
state_after: case h₂
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
i j : { unop := Z }.unop ⟶ { unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ }.unop
ij : { unop := Z }.unop.obj.left ⟶ c.pt := PullbackCone.IsLimit.lift hc i.left j.left ⋯
⊢ ∃ a, { unop := i } = (Over.homMk c.fst ⋯).op ≫ a ∧ { unop := j } = (Over.homMk c.snd ⋯).op ≫ a

tactic: refine ⟨Quiver.Hom.op (Over.homMk ij (by simpa [ij] using i.w)), ?_, ?_⟩
state_before: case h₂
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
i j : { unop := Z }.unop ⟶ { unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ }.unop
ij : { unop := Z }.unop.obj.left ⟶ c.pt := PullbackCone.IsLimit.lift hc i.left j.left ⋯
⊢ ∃ a, { unop := i } = (Over.homMk c.fst ⋯).op ≫ a ∧ { unop := j } = (Over.homMk c.snd ⋯).op ≫ a
state_after: case h₂.refine_1
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
i j : { unop := Z }.unop ⟶ { unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ }.unop
ij : { unop := Z }.unop.obj.left ⟶ c.pt := PullbackCone.IsLimit.lift hc i.left j.left ⋯
⊢ { unop := i } = (Over.homMk c.fst ⋯).op ≫ (Over.homMk ij ⋯).op

case h₂.refine_2
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
i j : { unop := Z }.unop ⟶ { unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ }.unop
ij : { unop := Z }.unop.obj.left ⟶ c.pt := PullbackCone.IsLimit.lift hc i.left j.left ⋯
⊢ { unop := j } = (Over.homMk c.snd ⋯).op ≫ (Over.homMk ij ⋯).op

tactic: all_goals congr
state_before: case h₂.refine_1
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
i j : { unop := Z }.unop ⟶ { unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ }.unop
ij : { unop := Z }.unop.obj.left ⟶ c.pt := PullbackCone.IsLimit.lift hc i.left j.left ⋯
⊢ { unop := i } = (Over.homMk c.fst ⋯).op ≫ (Over.homMk ij ⋯).op

case h₂.refine_2
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
i j : { unop := Z }.unop ⟶ { unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ }.unop
ij : { unop := Z }.unop.obj.left ⟶ c.pt := PullbackCone.IsLimit.lift hc i.left j.left ⋯
⊢ { unop := j } = (Over.homMk c.snd ⋯).op ≫ (Over.homMk ij ⋯).op
state_after: case h₂.refine_1.e_unop
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
i j : { unop := Z }.unop ⟶ { unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ }.unop
ij : { unop := Z }.unop.obj.left ⟶ c.pt := PullbackCone.IsLimit.lift hc i.left j.left ⋯
⊢ i = (Over.homMk ij ⋯).op.unop ≫ (Over.homMk c.fst ⋯).op.unop

case h₂.refine_2.e_unop
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
i j : { unop := Z }.unop ⟶ { unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ }.unop
ij : { unop := Z }.unop.obj.left ⟶ c.pt := PullbackCone.IsLimit.lift hc i.left j.left ⋯
⊢ j = (Over.homMk ij ⋯).op.unop ≫ (Over.homMk c.snd ⋯).op.unop

tactic: all_goals exact Comma.hom_ext _ _ (by erw [Over.comp_left]; simp [ij]) rfl
state_before: case h₂.refine_1.e_unop
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
i j : { unop := Z }.unop ⟶ { unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ }.unop
ij : { unop := Z }.unop.obj.left ⟶ c.pt := PullbackCone.IsLimit.lift hc i.left j.left ⋯
⊢ i = (Over.homMk ij ⋯).op.unop ≫ (Over.homMk c.fst ⋯).op.unop

case h₂.refine_2.e_unop
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
i j : { unop := Z }.unop ⟶ { unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ }.unop
ij : { unop := Z }.unop.obj.left ⟶ c.pt := PullbackCone.IsLimit.lift hc i.left j.left ⋯
⊢ j = (Over.homMk ij ⋯).op.unop ≫ (Over.homMk c.snd ⋯).op.unop
state_after: no goals

tactic: erw [i.w, j.w]
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
i j : { unop := Z }.unop ⟶ { unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ }.unop
⊢ i.left ≫ π = j.left ≫ π
state_after: C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
i j : { unop := Z }.unop ⟶ { unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ }.unop
⊢ { unop := Z }.unop.obj.hom ≫ (fromPUnit B).map i.right = { unop := Z }.unop.obj.hom ≫ (fromPUnit B).map j.right

tactic: rfl
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
i j : { unop := Z }.unop ⟶ { unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ }.unop
⊢ { unop := Z }.unop.obj.hom ≫ (fromPUnit B).map i.right = { unop := Z }.unop.obj.hom ≫ (fromPUnit B).map j.right
state_after: no goals

tactic: simpa [ij] using i.w
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
i j : { unop := Z }.unop ⟶ { unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ }.unop
ij : { unop := Z }.unop.obj.left ⟶ c.pt := PullbackCone.IsLimit.lift hc i.left j.left ⋯
⊢ ij ≫ ((Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk (c.fst ≫ π) ⋯).obj.hom = Z.obj.hom
state_after: no goals

tactic: congr
state_before: case h₂.refine_2
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
i j : { unop := Z }.unop ⟶ { unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ }.unop
ij : { unop := Z }.unop.obj.left ⟶ c.pt := PullbackCone.IsLimit.lift hc i.left j.left ⋯
⊢ { unop := j } = (Over.homMk c.snd ⋯).op ≫ (Over.homMk ij ⋯).op
state_after: case h₂.refine_2.e_unop
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
i j : { unop := Z }.unop ⟶ { unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ }.unop
ij : { unop := Z }.unop.obj.left ⟶ c.pt := PullbackCone.IsLimit.lift hc i.left j.left ⋯
⊢ j = (Over.homMk ij ⋯).op.unop ≫ (Over.homMk c.snd ⋯).op.unop

tactic: exact Comma.hom_ext _ _ (by erw [Over.comp_left]; simp [ij]) rfl
state_before: case h₂.refine_2.e_unop
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
i j : { unop := Z }.unop ⟶ { unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ }.unop
ij : { unop := Z }.unop.obj.left ⟶ c.pt := PullbackCone.IsLimit.lift hc i.left j.left ⋯
⊢ j = (Over.homMk ij ⋯).op.unop ≫ (Over.homMk c.snd ⋯).op.unop
state_after: no goals

tactic: erw [Over.comp_left]
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
i j : { unop := Z }.unop ⟶ { unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ }.unop
ij : { unop := Z }.unop.obj.left ⟶ c.pt := PullbackCone.IsLimit.lift hc i.left j.left ⋯
⊢ j.left = ((Over.homMk ij ⋯).op.unop ≫ (Over.homMk c.snd ⋯).op.unop).left
state_after: C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
i j : { unop := Z }.unop ⟶ { unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ }.unop
ij : { unop := Z }.unop.obj.left ⟶ c.pt := PullbackCone.IsLimit.lift hc i.left j.left ⋯
⊢ j.left = (Over.homMk ij ⋯).op.unop.left ≫ (Over.homMk c.snd ⋯).op.unop.left

tactic: simp [ij]
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.62148, u_2} D
inst✝ : Category.{?u.62152, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.category
i j : { unop := Z }.unop ⟶ { unop := (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯ }.unop
ij : { unop := Z }.unop.obj.left ⟶ c.pt := PullbackCone.IsLimit.lift hc i.left j.left ⋯
⊢ j.left = (Over.homMk ij ⋯).op.unop.left ≫ (Over.homMk c.snd ⋯).op.unop.left
state_after: no goals