Theorem: CategoryTheory.typeToCat_map
File: Mathlib/CategoryTheory/Category/Cat.lean

Proof steps:
state_before: X Y : Type u
f : X ⟶ Y
⊢ (fun X => Cat.of (Discrete X)) X ⟶ (fun X => Cat.of (Discrete X)) Y
state_after: X Y : Type u
f : X ⟶ Y
⊢ Cat.of (Discrete X) ⟶ Cat.of (Discrete Y)
tactic: dsimp
state_before: X Y : Type u
f : X ⟶ Y
⊢ Cat.of (Discrete X) ⟶ Cat.of (Discrete Y)
state_after: no goals
tactic: exact Discrete.functor (Discrete.mk ∘ f)
state_before: X : Type u
⊢ { obj := fun X => Cat.of (Discrete X), map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.map (𝟙 X) =
    𝟙 ({ obj := fun X => Cat.of (Discrete X), map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.obj X)
state_after: case h_map
X : Type u
⊢ autoParam
    (∀
      (X_1 Y :
        ↑({ obj := fun X => Cat.of (Discrete X), map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.obj X))
      (f : X_1 ⟶ Y),
      ({ obj := fun X => Cat.of (Discrete X), map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.map
              (𝟙 X)).map
          f =
        eqToHom ⋯ ≫
          (𝟙
                  ({ obj := fun X => Cat.of (Discrete X),
                        map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.obj
                    X)).map
              f ≫
            eqToHom ⋯)
    _auto✝

case h_obj
X : Type u
⊢ ∀
    (X_1 :
      ↑({ obj := fun X => Cat.of (Discrete X), map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.obj X)),
    ({ obj := fun X => Cat.of (Discrete X), map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.map
            (𝟙 X)).obj
        X_1 =
      (𝟙
            ({ obj := fun X => Cat.of (Discrete X), map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.obj
              X)).obj
        X_1
tactic: apply Functor.ext
state_before: X✝ Y✝ Z✝ : Type u
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ { obj := fun X => Cat.of (Discrete X), map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.map (f ≫ g) =
    { obj := fun X => Cat.of (Discrete X), map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.map f ≫
      { obj := fun X => Cat.of (Discrete X), map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.map g
state_after: case h_map
X✝ Y✝ Z✝ : Type u
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ autoParam
    (∀
      (X Y :
        ↑({ obj := fun X => Cat.of (Discrete X), map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.obj
            X✝))
      (f_1 : X ⟶ Y),
      ({ obj := fun X => Cat.of (Discrete X), map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.map
              (f ≫ g)).map
          f_1 =
        eqToHom ⋯ ≫
          ({ obj := fun X => Cat.of (Discrete X), map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.map
                    f ≫
                  { obj := fun X => Cat.of (Discrete X),
                        map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.map
                    g).map
              f_1 ≫
            eqToHom ⋯)
    _auto✝

case h_obj
X✝ Y✝ Z✝ : Type u
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ ∀
    (X :
      ↑({ obj := fun X => Cat.of (Discrete X), map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.obj X✝)),
    ({ obj := fun X => Cat.of (Discrete X), map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.map
            (f ≫ g)).obj
        X =
      ({ obj := fun X => Cat.of (Discrete X), map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.map f ≫
            { obj := fun X => Cat.of (Discrete X), map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.map
              g).obj
        X
tactic: apply Functor.ext
state_before: case h_map
X✝ Y✝ Z✝ : Type u
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ autoParam
    (∀
      (X Y :
        ↑({ obj := fun X => Cat.of (Discrete X), map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.obj
            X✝))
      (f_1 : X ⟶ Y),
      ({ obj := fun X => Cat.of (Discrete X), map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.map
              (f ≫ g)).map
          f_1 =
        eqToHom ⋯ ≫
          ({ obj := fun X => Cat.of (Discrete X), map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.map
                    f ≫
                  { obj := fun X => Cat.of (Discrete X),
                        map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.map
                    g).map
              f_1 ≫
            eqToHom ⋯)
    _auto✝

case h_obj
X✝ Y✝ Z✝ : Type u
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ ∀
    (X :
      ↑({ obj := fun X => Cat.of (Discrete X), map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.obj X✝)),
    ({ obj := fun X => Cat.of (Discrete X), map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.map
            (f ≫ g)).obj
        X =
      ({ obj := fun X => Cat.of (Discrete X), map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.map f ≫
            { obj := fun X => Cat.of (Discrete X), map := fun {X Y} f => id (Discrete.functor (Discrete.mk ∘ f)) }.map
              g).obj
        X
state_after: no goals
tactic: aesop_cat