Theorem: CategoryTheory.Mat.equivalenceSingleObjInverse_map
File: Mathlib/CategoryTheory/Preadditive/Mat.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Preadditive C
R : Type
inst✝ : Ring R
X : Mat_ (SingleObj Rᵐᵒᵖ)
⊢ { obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.map (𝟙 X) =
    𝟙 ({ obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.obj X)
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Preadditive C
R : Type
inst✝ : Ring R
X : Mat_ (SingleObj Rᵐᵒᵖ)
i✝ j✝ : ↑({ obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.obj X)
⊢ { obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.map (𝟙 X) i✝ j✝ =
    𝟙 ({ obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.obj X) i✝ j✝
tactic: ext
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Preadditive C
R : Type
inst✝ : Ring R
X : Mat_ (SingleObj Rᵐᵒᵖ)
i✝ j✝ : ↑({ obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.obj X)
⊢ { obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.map (𝟙 X) i✝ j✝ =
    𝟙 ({ obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.obj X) i✝ j✝
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Preadditive C
R : Type
inst✝ : Ring R
X : Mat_ (SingleObj Rᵐᵒᵖ)
i✝ j✝ : ↑({ obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.obj X)
⊢ MulOpposite.unop (if h : i✝ = j✝ then eqToHom ⋯ else 0) = if i✝ = j✝ then 1 else 0
tactic: simp only [Mat_.id_def, id_def]
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Preadditive C
R : Type
inst✝ : Ring R
X : Mat_ (SingleObj Rᵐᵒᵖ)
i✝ j✝ : ↑({ obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.obj X)
⊢ MulOpposite.unop (if h : i✝ = j✝ then eqToHom ⋯ else 0) = if i✝ = j✝ then 1 else 0
state_after: no goals
tactic: split_ifs <;> rfl
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Preadditive C
R : Type
inst✝ : Ring R
X✝ Y✝ Z✝ : Mat_ (SingleObj Rᵐᵒᵖ)
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ { obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.map (f ≫ g) =
    { obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.map f ≫
      { obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.map g
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Preadditive C
R : Type
inst✝ : Ring R
X✝ Y✝ Z✝ : Mat_ (SingleObj Rᵐᵒᵖ)
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
i✝ : ↑({ obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.obj X✝)
j✝ : ↑({ obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.obj Z✝)
⊢ { obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.map (f ≫ g) i✝ j✝ =
    ({ obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.map f ≫
        { obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.map g)
      i✝ j✝
tactic: ext
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Preadditive C
R : Type
inst✝ : Ring R
X✝ Y✝ Z✝ : Mat_ (SingleObj Rᵐᵒᵖ)
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
i✝ : ↑({ obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.obj X✝)
j✝ : ↑({ obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.obj Z✝)
⊢ { obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.map (f ≫ g) i✝ j✝ =
    ({ obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.map f ≫
        { obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.map g)
      i✝ j✝
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Preadditive C
R : Type
inst✝ : Ring R
X✝ Y✝ Z✝ : Mat_ (SingleObj Rᵐᵒᵖ)
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
i✝ : ↑({ obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.obj X✝)
j✝ : ↑({ obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.obj Z✝)
⊢ MulOpposite.unop (∑ j : Y✝.ι, f i✝ j ≫ g j j✝) =
    ∑ j : ↑(FintypeCat.of Y✝.ι), MulOpposite.unop (f i✝ j) * MulOpposite.unop (g j j✝)
tactic: simp only [Mat_.comp_apply, comp_apply]
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Preadditive C
R : Type
inst✝ : Ring R
X✝ Y✝ Z✝ : Mat_ (SingleObj Rᵐᵒᵖ)
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
i✝ : ↑({ obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.obj X✝)
j✝ : ↑({ obj := fun X => FintypeCat.of X.ι, map := fun {X Y} f i j => MulOpposite.unop (f i j) }.obj Z✝)
⊢ MulOpposite.unop (∑ j : Y✝.ι, f i✝ j ≫ g j j✝) =
    ∑ j : ↑(FintypeCat.of Y✝.ι), MulOpposite.unop (f i✝ j) * MulOpposite.unop (g j j✝)
state_after: no goals
tactic: apply Finset.unop_sum