Theorem: CategoryTheory.subterminalsEquivMonoOverTerminal_inverse_map
File: Mathlib/CategoryTheory/Subterminal.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
A : C
inst✝ : HasTerminal C
X✝ Y✝ : Subterminals C
f : X✝ ⟶ Y✝
⊢ f ≫ MonoOver.arrow ((fun X => { obj := Over.mk (terminal.from X.obj), property := ⋯ }) Y✝) =
    MonoOver.arrow ((fun X => { obj := Over.mk (terminal.from X.obj), property := ⋯ }) X✝)
state_after: no goals
tactic: ext1 ⟨⟨⟩⟩
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
A : C
inst✝ : HasTerminal C
X : MonoOver (⊤_ C)
Z : C
f g : Z ⟶ X.obj.left
⊢ f = g
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
A : C
inst✝ : HasTerminal C
X : MonoOver (⊤_ C)
Z : C
f g : Z ⟶ X.obj.left
⊢ f ≫ X.arrow = g ≫ X.arrow
tactic: rw [← cancel_mono X.arrow]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
A : C
inst✝ : HasTerminal C
X : MonoOver (⊤_ C)
Z : C
f g : Z ⟶ X.obj.left
⊢ f ≫ X.arrow = g ≫ X.arrow
state_after: no goals
tactic: subsingleton
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
A : C
inst✝ : HasTerminal C
⊢ ∀ {X Y : Subterminals C} (f : X ⟶ Y),
    (𝟭 (Subterminals C)).map f ≫ ((fun X => Iso.refl X) Y).hom =
      ((fun X => Iso.refl X) X).hom ≫
        ({ obj := fun X => { obj := Over.mk (terminal.from X.obj), property := ⋯ },
                map := fun {X Y} f => MonoOver.homMk f ⋯, map_id := ⋯, map_comp := ⋯ } ⋙
              { obj := fun X => { obj := X.obj.left, property := ⋯ }, map := fun {X Y} f => f.left, map_id := ⋯,
                map_comp := ⋯ }).map
          f
state_after: no goals
tactic: subsingleton
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
A : C
inst✝ : HasTerminal C
⊢ ∀ {X Y : MonoOver (⊤_ C)} (f : X ⟶ Y),
    ({ obj := fun X => { obj := X.obj.left, property := ⋯ }, map := fun {X Y} f => f.left, map_id := ⋯,
                map_comp := ⋯ } ⋙
              { obj := fun X => { obj := Over.mk (terminal.from X.obj), property := ⋯ },
                map := fun {X Y} f => MonoOver.homMk f ⋯, map_id := ⋯, map_comp := ⋯ }).map
          f ≫
        ((fun X =>
              MonoOver.isoMk
                (Iso.refl
                  (({ obj := fun X => { obj := X.obj.left, property := ⋯ }, map := fun {X Y} f => f.left, map_id := ⋯,
                              map_comp := ⋯ } ⋙
                            { obj := fun X => { obj := Over.mk (terminal.from X.obj), property := ⋯ },
                              map := fun {X Y} f => MonoOver.homMk f ⋯, map_id := ⋯, map_comp := ⋯ }).obj
                        X).obj.left)
                ⋯)
            Y).hom =
      ((fun X =>
              MonoOver.isoMk
                (Iso.refl
                  (({ obj := fun X => { obj := X.obj.left, property := ⋯ }, map := fun {X Y} f => f.left, map_id := ⋯,
                              map_comp := ⋯ } ⋙
                            { obj := fun X => { obj := Over.mk (terminal.from X.obj), property := ⋯ },
                              map := fun {X Y} f => MonoOver.homMk f ⋯, map_id := ⋯, map_comp := ⋯ }).obj
                        X).obj.left)
                ⋯)
            X).hom ≫
        (𝟭 (MonoOver (⊤_ C))).map f
state_after: no goals
tactic: subsingleton
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
A : C
inst✝ : HasTerminal C
⊢ ∀ (X : Subterminals C),
    { obj := fun X => { obj := Over.mk (terminal.from X.obj), property := ⋯ }, map := fun {X Y} f => MonoOver.homMk f ⋯,
              map_id := ⋯, map_comp := ⋯ }.map
          ((NatIso.ofComponents (fun X => Iso.refl X) ⋯).hom.app X) ≫
        (NatIso.ofComponents
                (fun X =>
                  MonoOver.isoMk
                    (Iso.refl
                      (({ obj := fun X => { obj := X.obj.left, property := ⋯ }, map := fun {X Y} f => f.left,
                                  map_id := ⋯, map_comp := ⋯ } ⋙
                                { obj := fun X => { obj := Over.mk (terminal.from X.obj), property := ⋯ },
                                  map := fun {X Y} f => MonoOver.homMk f ⋯, map_id := ⋯, map_comp := ⋯ }).obj
                            X).obj.left)
                    ⋯)
                ⋯).hom.app
          ({ obj := fun X => { obj := Over.mk (terminal.from X.obj), property := ⋯ },
                map := fun {X Y} f => MonoOver.homMk f ⋯, map_id := ⋯, map_comp := ⋯ }.obj
            X) =
      𝟙
        ({ obj := fun X => { obj := Over.mk (terminal.from X.obj), property := ⋯ },
              map := fun {X Y} f => MonoOver.homMk f ⋯, map_id := ⋯, map_comp := ⋯ }.obj
          X)
state_after: no goals
tactic: subsingleton