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

tactic: intro 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.16369, u_2} D
inst✝ : Category.{?u.16373, u_3} E
P : Cᵒᵖ ⥤ Type u_4
hP : EqualizerCondition P
⊢ ∀ (X B : C) (π : X ⟶ B) [inst : EffectiveEpi π] [inst : HasPullback π π],
    Function.Bijective (MapToEqualizer P π pullback.fst pullback.snd ⋯)
state_after: C : Type u_1
D : Type u_2
E : Type u_3
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Category.{?u.16369, u_2} D
inst✝² : Category.{?u.16373, u_3} E
P : Cᵒᵖ ⥤ Type u_4
hP : EqualizerCondition P
X B : C
π : X ⟶ B
inst✝¹ : EffectiveEpi π
inst✝ : HasPullback π π
⊢ Function.Bijective (MapToEqualizer P π pullback.fst pullback.snd ⋯)

tactic: specialize hP π _ (pullbackIsPullback π π)
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Category.{?u.16369, u_2} D
inst✝² : Category.{?u.16373, u_3} E
P : Cᵒᵖ ⥤ Type u_4
hP : EqualizerCondition P
X B : C
π : X ⟶ B
inst✝¹ : EffectiveEpi π
inst✝ : HasPullback π π
⊢ Function.Bijective (MapToEqualizer P π pullback.fst pullback.snd ⋯)
state_after: C : Type u_1
D : Type u_2
E : Type u_3
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Category.{?u.16369, u_2} D
inst✝² : Category.{?u.16373, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝¹ : EffectiveEpi π
inst✝ : HasPullback π π
hP : Nonempty (IsLimit (Fork.ofι (P.map π.op) ⋯))
⊢ Function.Bijective (MapToEqualizer P π pullback.fst pullback.snd ⋯)

tactic: rw [Types.type_equalizer_iff_unique] 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.16369, u_2} D
inst✝² : Category.{?u.16373, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝¹ : EffectiveEpi π
inst✝ : HasPullback π π
hP : Nonempty (IsLimit (Fork.ofι (P.map π.op) ⋯))
⊢ Function.Bijective (MapToEqualizer P π pullback.fst pullback.snd ⋯)
state_after: C : Type u_1
D : Type u_2
E : Type u_3
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Category.{?u.16369, u_2} D
inst✝² : Category.{?u.16373, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝¹ : EffectiveEpi π
inst✝ : HasPullback π π
hP :
  ∀ (y : P.obj { unop := X }),
    P.map (PullbackCone.mk pullback.fst pullback.snd ⋯).fst.op y =
        P.map (PullbackCone.mk pullback.fst pullback.snd ⋯).snd.op y →
      ∃! x, P.map π.op x = y
⊢ Function.Bijective (MapToEqualizer P π pullback.fst pullback.snd ⋯)

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

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.16369, u_2} D
inst✝² : Category.{?u.16373, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝¹ : EffectiveEpi π
inst✝ : HasPullback π π
hP :
  ∀ (y : P.obj { unop := X }),
    P.map (PullbackCone.mk pullback.fst pullback.snd ⋯).fst.op y =
        P.map (PullbackCone.mk pullback.fst pullback.snd ⋯).snd.op y →
      ∃! x, P.map π.op x = y
⊢ ∀ (b : ↑{x | P.map pullback.fst.op x = P.map pullback.snd.op x}),
    ∃! a, MapToEqualizer P π pullback.fst pullback.snd ⋯ a = 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.16369, u_2} D
inst✝² : Category.{?u.16373, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝¹ : EffectiveEpi π
inst✝ : HasPullback π π
hP :
  ∀ (y : P.obj { unop := X }),
    P.map (PullbackCone.mk pullback.fst pullback.snd ⋯).fst.op y =
        P.map (PullbackCone.mk pullback.fst pullback.snd ⋯).snd.op y →
      ∃! x, P.map π.op x = y
b : P.obj { unop := X }
hb : b ∈ {x | P.map pullback.fst.op x = P.map pullback.snd.op x}
⊢ ∃! a, MapToEqualizer P π pullback.fst pullback.snd ⋯ a = ⟨b, hb⟩

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.16369, u_2} D
inst✝² : Category.{?u.16373, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝¹ : EffectiveEpi π
inst✝ : HasPullback π π
hP :
  ∀ (y : P.obj { unop := X }),
    P.map (PullbackCone.mk pullback.fst pullback.snd ⋯).fst.op y =
        P.map (PullbackCone.mk pullback.fst pullback.snd ⋯).snd.op y →
      ∃! x, P.map π.op x = y
b : P.obj { unop := X }
hb : b ∈ {x | P.map pullback.fst.op x = P.map pullback.snd.op x}
⊢ ∃! a, MapToEqualizer P π pullback.fst pullback.snd ⋯ a = ⟨b, hb⟩
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.16369, u_2} D
inst✝² : Category.{?u.16373, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝¹ : EffectiveEpi π
inst✝ : HasPullback π π
hP :
  ∀ (y : P.obj { unop := X }),
    P.map (PullbackCone.mk pullback.fst pullback.snd ⋯).fst.op y =
        P.map (PullbackCone.mk pullback.fst pullback.snd ⋯).snd.op y →
      ∃! x, P.map π.op x = y
b : P.obj { unop := X }
hb : b ∈ {x | P.map pullback.fst.op x = P.map pullback.snd.op x}
a : P.obj { unop := B }
ha₁ : P.map π.op a = b
ha₂ : ∀ (y : P.obj { unop := B }), (fun x => P.map π.op x = b) y → y = a
⊢ ∃! a, MapToEqualizer P π pullback.fst pullback.snd ⋯ a = ⟨b, hb⟩

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.16369, u_2} D
inst✝² : Category.{?u.16373, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝¹ : EffectiveEpi π
inst✝ : HasPullback π π
hP :
  ∀ (y : P.obj { unop := X }),
    P.map (PullbackCone.mk pullback.fst pullback.snd ⋯).fst.op y =
        P.map (PullbackCone.mk pullback.fst pullback.snd ⋯).snd.op y →
      ∃! x, P.map π.op x = y
b : P.obj { unop := X }
hb : b ∈ {x | P.map pullback.fst.op x = P.map pullback.snd.op x}
a : P.obj { unop := B }
ha₁ : P.map π.op a = b
ha₂ : ∀ (y : P.obj { unop := B }), (fun x => P.map π.op x = b) y → y = a
⊢ ∃! a, MapToEqualizer P π pullback.fst pullback.snd ⋯ a = ⟨b, hb⟩
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.16369, u_2} D
inst✝² : Category.{?u.16373, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝¹ : EffectiveEpi π
inst✝ : HasPullback π π
hP :
  ∀ (y : P.obj { unop := X }),
    P.map (PullbackCone.mk pullback.fst pullback.snd ⋯).fst.op y =
        P.map (PullbackCone.mk pullback.fst pullback.snd ⋯).snd.op y →
      ∃! x, P.map π.op x = y
b : P.obj { unop := X }
hb : b ∈ {x | P.map pullback.fst.op x = P.map pullback.snd.op x}
a : P.obj { unop := B }
ha₁ : P.map π.op a = b
ha₂ : ∀ (y : P.obj { unop := B }), (fun x => P.map π.op x = b) y → y = a
⊢ (fun a => MapToEqualizer P π pullback.fst pullback.snd ⋯ a = ⟨b, hb⟩) 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.16369, u_2} D
inst✝² : Category.{?u.16373, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝¹ : EffectiveEpi π
inst✝ : HasPullback π π
hP :
  ∀ (y : P.obj { unop := X }),
    P.map (PullbackCone.mk pullback.fst pullback.snd ⋯).fst.op y =
        P.map (PullbackCone.mk pullback.fst pullback.snd ⋯).snd.op y →
      ∃! x, P.map π.op x = y
b : P.obj { unop := X }
hb : b ∈ {x | P.map pullback.fst.op x = P.map pullback.snd.op x}
a : P.obj { unop := B }
ha₁ : P.map π.op a = b
ha₂ : ∀ (y : P.obj { unop := B }), (fun x => P.map π.op x = b) y → y = a
⊢ ∀ (y : P.obj { unop := B }), (fun a => MapToEqualizer P π pullback.fst pullback.snd ⋯ a = ⟨b, hb⟩) y → y = a

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.16369, u_2} D
inst✝² : Category.{?u.16373, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝¹ : EffectiveEpi π
inst✝ : HasPullback π π
hP :
  ∀ (y : P.obj { unop := X }),
    P.map (PullbackCone.mk pullback.fst pullback.snd ⋯).fst.op y =
        P.map (PullbackCone.mk pullback.fst pullback.snd ⋯).snd.op y →
      ∃! x, P.map π.op x = y
b : P.obj { unop := X }
hb : b ∈ {x | P.map pullback.fst.op x = P.map pullback.snd.op x}
a : P.obj { unop := B }
ha₁ : P.map π.op a = b
ha₂ : ∀ (y : P.obj { unop := B }), (fun x => P.map π.op x = b) y → y = a
⊢ (fun a => MapToEqualizer P π pullback.fst pullback.snd ⋯ a = ⟨b, hb⟩) 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.16369, u_2} D
inst✝² : Category.{?u.16373, u_3} E
P : Cᵒᵖ ⥤ Type u_4
X B : C
π : X ⟶ B
inst✝¹ : EffectiveEpi π
inst✝ : HasPullback π π
hP :
  ∀ (y : P.obj { unop := X }),
    P.map (PullbackCone.mk pullback.fst pullback.snd ⋯).fst.op y =
        P.map (PullbackCone.mk pullback.fst pullback.snd ⋯).snd.op y →
      ∃! x, P.map π.op x = y
b : P.obj { unop := X }
hb : b ∈ {x | P.map pullback.fst.op x = P.map pullback.snd.op x}
a : P.obj { unop := B }
ha₁ : P.map π.op a = b
ha₂ : ∀ (y : P.obj { unop := B }), (fun x => P.map π.op x = b) y → y = a
⊢ ∀ (y : P.obj { unop := B }), (fun a => MapToEqualizer P π pullback.fst pullback.snd ⋯ a = ⟨b, hb⟩) y → y = a
state_after: no goals