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

tactic: intro X B π _ c hc
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_5, u_1} C
inst✝¹ : Category.{?u.23562, u_2} D
inst✝ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
hP :
  ∀ (X B : C) (π : X ⟶ B) [inst : EffectiveEpi π] [inst : HasPullback π π],
    Function.Bijective (MapToEqualizer P π pullback.fst pullback.snd ⋯)
⊢ EqualizerCondition P
state_after: C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
hP :
  ∀ (X B : C) (π : X ⟶ B) [inst : EffectiveEpi π] [inst : HasPullback π π],
    Function.Bijective (MapToEqualizer P π pullback.fst pullback.snd ⋯)
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
⊢ Nonempty (IsLimit (Fork.ofι (P.map π.op) ⋯))

tactic: have : HasPullback π π := ⟨c, hc⟩
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
hP :
  ∀ (X B : C) (π : X ⟶ B) [inst : EffectiveEpi π] [inst : HasPullback π π],
    Function.Bijective (MapToEqualizer P π pullback.fst pullback.snd ⋯)
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
⊢ Nonempty (IsLimit (Fork.ofι (P.map π.op) ⋯))
state_after: C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
hP :
  ∀ (X B : C) (π : X ⟶ B) [inst : EffectiveEpi π] [inst : HasPullback π π],
    Function.Bijective (MapToEqualizer P π pullback.fst pullback.snd ⋯)
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
this : HasPullback π π
⊢ Nonempty (IsLimit (Fork.ofι (P.map π.op) ⋯))

tactic: specialize hP X B π
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
hP :
  ∀ (X B : C) (π : X ⟶ B) [inst : EffectiveEpi π] [inst : HasPullback π π],
    Function.Bijective (MapToEqualizer P π pullback.fst pullback.snd ⋯)
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
this : HasPullback π π
⊢ Nonempty (IsLimit (Fork.ofι (P.map π.op) ⋯))
state_after: C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
this : HasPullback π π
hP : Function.Bijective (MapToEqualizer P π pullback.fst pullback.snd ⋯)
⊢ Nonempty (IsLimit (Fork.ofι (P.map π.op) ⋯))

tactic: rw [Types.type_equalizer_iff_unique]
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
this : HasPullback π π
hP : Function.Bijective (MapToEqualizer P π pullback.fst pullback.snd ⋯)
⊢ Nonempty (IsLimit (Fork.ofι (P.map π.op) ⋯))
state_after: C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
this : HasPullback π π
hP : Function.Bijective (MapToEqualizer P π pullback.fst pullback.snd ⋯)
⊢ ∀ (y : P.obj { unop := X }), P.map c.fst.op y = P.map c.snd.op y → ∃! x, P.map π.op x = y

tactic: rw [Function.bijective_iff_existsUnique] at hP
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
this : HasPullback π π
hP : Function.Bijective (MapToEqualizer P π pullback.fst pullback.snd ⋯)
⊢ ∀ (y : P.obj { unop := X }), P.map c.fst.op y = P.map c.snd.op y → ∃! x, P.map π.op x = y
state_after: C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
this : HasPullback π π
hP :
  ∀ (b : ↑{x | P.map pullback.fst.op x = P.map pullback.snd.op x}),
    ∃! a, MapToEqualizer P π pullback.fst pullback.snd ⋯ a = b
⊢ ∀ (y : P.obj { unop := X }), P.map c.fst.op y = P.map c.snd.op y → ∃! x, P.map π.op x = y

tactic: intro b hb
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
this : HasPullback π π
hP :
  ∀ (b : ↑{x | P.map pullback.fst.op x = P.map pullback.snd.op x}),
    ∃! a, MapToEqualizer P π pullback.fst pullback.snd ⋯ a = b
⊢ ∀ (y : P.obj { unop := X }), P.map c.fst.op y = P.map c.snd.op y → ∃! x, P.map π.op x = y
state_after: C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
this : HasPullback π π
hP :
  ∀ (b : ↑{x | P.map pullback.fst.op x = P.map pullback.snd.op x}),
    ∃! a, MapToEqualizer P π pullback.fst pullback.snd ⋯ a = b
b : P.obj { unop := X }
hb : P.map c.fst.op b = P.map c.snd.op b
⊢ ∃! x, P.map π.op x = b

tactic: have h₁ : ((pullbackIsPullback π π).conePointUniqueUpToIso hc).hom ≫ c.fst =
  pullback.fst (f := π) (g := π) := by simp
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
this : HasPullback π π
hP :
  ∀ (b : ↑{x | P.map pullback.fst.op x = P.map pullback.snd.op x}),
    ∃! a, MapToEqualizer P π pullback.fst pullback.snd ⋯ a = b
b : P.obj { unop := X }
hb : P.map c.fst.op b = P.map c.snd.op b
⊢ ∃! x, P.map π.op x = b
state_after: C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
this : HasPullback π π
hP :
  ∀ (b : ↑{x | P.map pullback.fst.op x = P.map pullback.snd.op x}),
    ∃! a, MapToEqualizer P π pullback.fst pullback.snd ⋯ a = b
b : P.obj { unop := X }
hb : P.map c.fst.op b = P.map c.snd.op b
h₁ : ((pullbackIsPullback π π).conePointUniqueUpToIso hc).hom ≫ c.fst = pullback.fst
⊢ ∃! x, P.map π.op x = b

tactic: have hb' : P.map (pullback.fst (f := π) (g := π)).op b = P.map pullback.snd.op b := by
  rw [← h₁, op_comp, FunctorToTypes.map_comp_apply, hb]
  simp [← FunctorToTypes.map_comp_apply, ← op_comp]
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
this : HasPullback π π
hP :
  ∀ (b : ↑{x | P.map pullback.fst.op x = P.map pullback.snd.op x}),
    ∃! a, MapToEqualizer P π pullback.fst pullback.snd ⋯ a = b
b : P.obj { unop := X }
hb : P.map c.fst.op b = P.map c.snd.op b
h₁ : ((pullbackIsPullback π π).conePointUniqueUpToIso hc).hom ≫ c.fst = pullback.fst
⊢ ∃! x, P.map π.op x = b
state_after: C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
this : HasPullback π π
hP :
  ∀ (b : ↑{x | P.map pullback.fst.op x = P.map pullback.snd.op x}),
    ∃! a, MapToEqualizer P π pullback.fst pullback.snd ⋯ a = b
b : P.obj { unop := X }
hb : P.map c.fst.op b = P.map c.snd.op b
h₁ : ((pullbackIsPullback π π).conePointUniqueUpToIso hc).hom ≫ c.fst = pullback.fst
hb' : P.map pullback.fst.op b = P.map pullback.snd.op b
⊢ ∃! x, P.map π.op x = b

tactic: obtain ⟨a, ha₁, ha₂⟩ := hP ⟨b, hb'⟩
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
this : HasPullback π π
hP :
  ∀ (b : ↑{x | P.map pullback.fst.op x = P.map pullback.snd.op x}),
    ∃! a, MapToEqualizer P π pullback.fst pullback.snd ⋯ a = b
b : P.obj { unop := X }
hb : P.map c.fst.op b = P.map c.snd.op b
h₁ : ((pullbackIsPullback π π).conePointUniqueUpToIso hc).hom ≫ c.fst = pullback.fst
hb' : P.map pullback.fst.op b = P.map pullback.snd.op b
⊢ ∃! x, P.map π.op x = b
state_after: case intro.intro
C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
this : HasPullback π π
hP :
  ∀ (b : ↑{x | P.map pullback.fst.op x = P.map pullback.snd.op x}),
    ∃! a, MapToEqualizer P π pullback.fst pullback.snd ⋯ a = b
b : P.obj { unop := X }
hb : P.map c.fst.op b = P.map c.snd.op b
h₁ : ((pullbackIsPullback π π).conePointUniqueUpToIso hc).hom ≫ c.fst = pullback.fst
hb' : P.map pullback.fst.op b = P.map pullback.snd.op b
a : P.obj { unop := B }
ha₁ : MapToEqualizer P π pullback.fst pullback.snd ⋯ a = ⟨b, hb'⟩
ha₂ : ∀ (y : P.obj { unop := B }), (fun a => MapToEqualizer P π pullback.fst pullback.snd ⋯ a = ⟨b, hb'⟩) y → y = a
⊢ ∃! x, P.map π.op x = b

tactic: refine ⟨a, ?_, ?_⟩
state_before: case intro.intro
C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
this : HasPullback π π
hP :
  ∀ (b : ↑{x | P.map pullback.fst.op x = P.map pullback.snd.op x}),
    ∃! a, MapToEqualizer P π pullback.fst pullback.snd ⋯ a = b
b : P.obj { unop := X }
hb : P.map c.fst.op b = P.map c.snd.op b
h₁ : ((pullbackIsPullback π π).conePointUniqueUpToIso hc).hom ≫ c.fst = pullback.fst
hb' : P.map pullback.fst.op b = P.map pullback.snd.op b
a : P.obj { unop := B }
ha₁ : MapToEqualizer P π pullback.fst pullback.snd ⋯ a = ⟨b, hb'⟩
ha₂ : ∀ (y : P.obj { unop := B }), (fun a => MapToEqualizer P π pullback.fst pullback.snd ⋯ a = ⟨b, hb'⟩) y → y = a
⊢ ∃! x, P.map π.op x = b
state_after: case intro.intro.refine_1
C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
this : HasPullback π π
hP :
  ∀ (b : ↑{x | P.map pullback.fst.op x = P.map pullback.snd.op x}),
    ∃! a, MapToEqualizer P π pullback.fst pullback.snd ⋯ a = b
b : P.obj { unop := X }
hb : P.map c.fst.op b = P.map c.snd.op b
h₁ : ((pullbackIsPullback π π).conePointUniqueUpToIso hc).hom ≫ c.fst = pullback.fst
hb' : P.map pullback.fst.op b = P.map pullback.snd.op b
a : P.obj { unop := B }
ha₁ : MapToEqualizer P π pullback.fst pullback.snd ⋯ a = ⟨b, hb'⟩
ha₂ : ∀ (y : P.obj { unop := B }), (fun a => MapToEqualizer P π pullback.fst pullback.snd ⋯ a = ⟨b, hb'⟩) y → y = a
⊢ (fun x => P.map π.op x = b) a

case intro.intro.refine_2
C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
this : HasPullback π π
hP :
  ∀ (b : ↑{x | P.map pullback.fst.op x = P.map pullback.snd.op x}),
    ∃! a, MapToEqualizer P π pullback.fst pullback.snd ⋯ a = b
b : P.obj { unop := X }
hb : P.map c.fst.op b = P.map c.snd.op b
h₁ : ((pullbackIsPullback π π).conePointUniqueUpToIso hc).hom ≫ c.fst = pullback.fst
hb' : P.map pullback.fst.op b = P.map pullback.snd.op b
a : P.obj { unop := B }
ha₁ : MapToEqualizer P π pullback.fst pullback.snd ⋯ a = ⟨b, hb'⟩
ha₂ : ∀ (y : P.obj { unop := B }), (fun a => MapToEqualizer P π pullback.fst pullback.snd ⋯ a = ⟨b, hb'⟩) y → y = a
⊢ ∀ (y : P.obj { unop := B }), (fun x => P.map π.op x = b) y → y = a

tactic: simp
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
this : HasPullback π π
hP :
  ∀ (b : ↑{x | P.map pullback.fst.op x = P.map pullback.snd.op x}),
    ∃! a, MapToEqualizer P π pullback.fst pullback.snd ⋯ a = b
b : P.obj { unop := X }
hb : P.map c.fst.op b = P.map c.snd.op b
⊢ ((pullbackIsPullback π π).conePointUniqueUpToIso hc).hom ≫ c.fst = pullback.fst
state_after: no goals

tactic: rw [← h₁, op_comp, FunctorToTypes.map_comp_apply, hb]
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
this : HasPullback π π
hP :
  ∀ (b : ↑{x | P.map pullback.fst.op x = P.map pullback.snd.op x}),
    ∃! a, MapToEqualizer P π pullback.fst pullback.snd ⋯ a = b
b : P.obj { unop := X }
hb : P.map c.fst.op b = P.map c.snd.op b
h₁ : ((pullbackIsPullback π π).conePointUniqueUpToIso hc).hom ≫ c.fst = pullback.fst
⊢ P.map pullback.fst.op b = P.map pullback.snd.op b
state_after: C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
this : HasPullback π π
hP :
  ∀ (b : ↑{x | P.map pullback.fst.op x = P.map pullback.snd.op x}),
    ∃! a, MapToEqualizer P π pullback.fst pullback.snd ⋯ a = b
b : P.obj { unop := X }
hb : P.map c.fst.op b = P.map c.snd.op b
h₁ : ((pullbackIsPullback π π).conePointUniqueUpToIso hc).hom ≫ c.fst = pullback.fst
⊢ P.map ((pullbackIsPullback π π).conePointUniqueUpToIso hc).hom.op (P.map c.snd.op b) = P.map pullback.snd.op b

tactic: simp [← FunctorToTypes.map_comp_apply, ← op_comp]
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
this : HasPullback π π
hP :
  ∀ (b : ↑{x | P.map pullback.fst.op x = P.map pullback.snd.op x}),
    ∃! a, MapToEqualizer P π pullback.fst pullback.snd ⋯ a = b
b : P.obj { unop := X }
hb : P.map c.fst.op b = P.map c.snd.op b
h₁ : ((pullbackIsPullback π π).conePointUniqueUpToIso hc).hom ≫ c.fst = pullback.fst
⊢ P.map ((pullbackIsPullback π π).conePointUniqueUpToIso hc).hom.op (P.map c.snd.op b) = P.map pullback.snd.op b
state_after: no goals

tactic: simpa [MapToEqualizer] using ha₁
state_before: case intro.intro.refine_1
C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
this : HasPullback π π
hP :
  ∀ (b : ↑{x | P.map pullback.fst.op x = P.map pullback.snd.op x}),
    ∃! a, MapToEqualizer P π pullback.fst pullback.snd ⋯ a = b
b : P.obj { unop := X }
hb : P.map c.fst.op b = P.map c.snd.op b
h₁ : ((pullbackIsPullback π π).conePointUniqueUpToIso hc).hom ≫ c.fst = pullback.fst
hb' : P.map pullback.fst.op b = P.map pullback.snd.op b
a : P.obj { unop := B }
ha₁ : MapToEqualizer P π pullback.fst pullback.snd ⋯ a = ⟨b, hb'⟩
ha₂ : ∀ (y : P.obj { unop := B }), (fun a => MapToEqualizer P π pullback.fst pullback.snd ⋯ a = ⟨b, hb'⟩) y → y = a
⊢ (fun x => P.map π.op x = b) a
state_after: no goals

tactic: simpa [MapToEqualizer] using ha₂
state_before: case intro.intro.refine_2
C : Type u_1
D : Type u_2
E : Type u_3
inst✝³ : Category.{u_5, u_1} C
inst✝² : Category.{?u.23562, u_2} D
inst✝¹ : Category.{?u.23566, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
this : HasPullback π π
hP :
  ∀ (b : ↑{x | P.map pullback.fst.op x = P.map pullback.snd.op x}),
    ∃! a, MapToEqualizer P π pullback.fst pullback.snd ⋯ a = b
b : P.obj { unop := X }
hb : P.map c.fst.op b = P.map c.snd.op b
h₁ : ((pullbackIsPullback π π).conePointUniqueUpToIso hc).hom ≫ c.fst = pullback.fst
hb' : P.map pullback.fst.op b = P.map pullback.snd.op b
a : P.obj { unop := B }
ha₁ : MapToEqualizer P π pullback.fst pullback.snd ⋯ a = ⟨b, hb'⟩
ha₂ : ∀ (y : P.obj { unop := B }), (fun a => MapToEqualizer P π pullback.fst pullback.snd ⋯ a = ⟨b, hb'⟩) y → y = a
⊢ ∀ (y : P.obj { unop := B }), (fun x => P.map π.op x = b) y → y = a
state_after: no goals