Theorem: pointedToPartialFun_map
File: Mathlib/CategoryTheory/Category/PartialFun.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
X✝ Y✝ Z✝ : Pointed
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ { obj := fun X => { x // x ≠ X.point },
          map := fun {X Y} f => PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val }.map
      (f ≫ g) =
    { obj := fun X => { x // x ≠ X.point },
            map := fun {X Y} f => PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val }.map
        f ≫
      { obj := fun X => { x // x ≠ X.point },
            map := fun {X Y} f => PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val }.map
        g
state_after: α : Type u_1
β : Type u_2
X✝ Y✝ Z✝ : Pointed
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ ∀
    (a :
      { obj := fun X => { x // x ≠ X.point },
            map := fun {X Y} f => PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val }.obj
        X✝)
    (b :
      { obj := fun X => { x // x ≠ X.point },
            map := fun {X Y} f => PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val }.obj
        Z✝),
    b ∈
        { obj := fun X => { x // x ≠ X.point },
              map := fun {X Y} f => PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val }.map
          (f ≫ g) a ↔
      b ∈
        ({ obj := fun X => { x // x ≠ X.point },
                  map := fun {X Y} f => PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val }.map
              f ≫
            { obj := fun X => { x // x ≠ X.point },
                  map := fun {X Y} f => PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val }.map
              g)
          a
tactic: apply PFun.ext _
state_before: α : Type u_1
β : Type u_2
X✝ Y✝ Z✝ : Pointed
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ ∀
    (a :
      { obj := fun X => { x // x ≠ X.point },
            map := fun {X Y} f => PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val }.obj
        X✝)
    (b :
      { obj := fun X => { x // x ≠ X.point },
            map := fun {X Y} f => PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val }.obj
        Z✝),
    b ∈
        { obj := fun X => { x // x ≠ X.point },
              map := fun {X Y} f => PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val }.map
          (f ≫ g) a ↔
      b ∈
        ({ obj := fun X => { x // x ≠ X.point },
                  map := fun {X Y} f => PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val }.map
              f ≫
            { obj := fun X => { x // x ≠ X.point },
                  map := fun {X Y} f => PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val }.map
              g)
          a
state_after: case mk.mk
α : Type u_1
β : Type u_2
X✝ Y✝ Z✝ : Pointed
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
a : X✝.X
ha : a ≠ X✝.point
c : Z✝.X
hc : c ≠ Z✝.point
⊢ ⟨c, hc⟩ ∈
      { obj := fun X => { x // x ≠ X.point },
            map := fun {X Y} f => PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val }.map
        (f ≫ g) ⟨a, ha⟩ ↔
    ⟨c, hc⟩ ∈
      ({ obj := fun X => { x // x ≠ X.point },
                map := fun {X Y} f => PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val }.map
            f ≫
          { obj := fun X => { x // x ≠ X.point },
                map := fun {X Y} f => PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val }.map
            g)
        ⟨a, ha⟩
tactic: rintro ⟨a, ha⟩ ⟨c, hc⟩
state_before: case mk.mk
α : Type u_1
β : Type u_2
X✝ Y✝ Z✝ : Pointed
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
a : X✝.X
ha : a ≠ X✝.point
c : Z✝.X
hc : c ≠ Z✝.point
⊢ ⟨c, hc⟩ ∈
      { obj := fun X => { x // x ≠ X.point },
            map := fun {X Y} f => PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val }.map
        (f ≫ g) ⟨a, ha⟩ ↔
    ⟨c, hc⟩ ∈
      ({ obj := fun X => { x // x ≠ X.point },
                map := fun {X Y} f => PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val }.map
            f ≫
          { obj := fun X => { x // x ≠ X.point },
                map := fun {X Y} f => PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val }.map
            g)
        ⟨a, ha⟩
state_after: case mk.mk.mp
α : Type u_1
β : Type u_2
X✝ Y✝ Z✝ : Pointed
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
a : X✝.X
ha : a ≠ X✝.point
c : Z✝.X
hc : c ≠ Z✝.point
⊢ ⟨c, hc⟩ ∈
      { obj := fun X => { x // x ≠ X.point },
            map := fun {X Y} f => PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val }.map
        (f ≫ g) ⟨a, ha⟩ →
    ⟨c, hc⟩ ∈
      ({ obj := fun X => { x // x ≠ X.point },
                map := fun {X Y} f => PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val }.map
            f ≫
          { obj := fun X => { x // x ≠ X.point },
                map := fun {X Y} f => PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val }.map
            g)
        ⟨a, ha⟩

case mk.mk.mpr
α : Type u_1
β : Type u_2
X✝ Y✝ Z✝ : Pointed
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
a : X✝.X
ha : a ≠ X✝.point
c : Z✝.X
hc : c ≠ Z✝.point
⊢ ⟨c, hc⟩ ∈
      ({ obj := fun X => { x // x ≠ X.point },
                map := fun {X Y} f => PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val }.map
            f ≫
          { obj := fun X => { x // x ≠ X.point },
                map := fun {X Y} f => PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val }.map
            g)
        ⟨a, ha⟩ →
    ⟨c, hc⟩ ∈
      { obj := fun X => { x // x ≠ X.point },
            map := fun {X Y} f => PFun.toSubtype (fun x => x ≠ Y.point) f.toFun ∘ Subtype.val }.map
        (f ≫ g) ⟨a, ha⟩
tactic: constructor