Theorem: Bimod.LeftUnitorBimod.hom_inv_id
File: Mathlib/CategoryTheory/Monoidal/Bimod.lean

tactic: dsimp only [hom, inv, TensorBimod.X]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝ : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
⊢ hom P ≫ inv P = 𝟙 (TensorBimod.X (regular R) P)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝ : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
⊢ coequalizer.desc P.actLeft ⋯ ≫
      (λ_ P.X).inv ≫
        R.one ▷ P.X ≫
          coequalizer.π ((regular R).actRight ▷ P.X) ((α_ (regular R).X R.X P.X).hom ≫ (regular R).X ◁ P.actLeft) =
    𝟙 (coequalizer ((regular R).actRight ▷ P.X) ((α_ (regular R).X R.X P.X).hom ≫ (regular R).X ◁ P.actLeft))

tactic: ext
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝ : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
⊢ coequalizer.desc P.actLeft ⋯ ≫
      (λ_ P.X).inv ≫
        R.one ▷ P.X ≫
          coequalizer.π ((regular R).actRight ▷ P.X) ((α_ (regular R).X R.X P.X).hom ≫ (regular R).X ◁ P.actLeft) =
    𝟙 (coequalizer ((regular R).actRight ▷ P.X) ((α_ (regular R).X R.X P.X).hom ≫ (regular R).X ◁ P.actLeft))
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝ : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
⊢ coequalizer.π ((regular R).actRight ▷ P.X) ((α_ (regular R).X R.X P.X).hom ≫ (regular R).X ◁ P.actLeft) ≫
      coequalizer.desc P.actLeft ⋯ ≫
        (λ_ P.X).inv ≫
          R.one ▷ P.X ≫
            coequalizer.π ((regular R).actRight ▷ P.X) ((α_ (regular R).X R.X P.X).hom ≫ (regular R).X ◁ P.actLeft) =
    coequalizer.π ((regular R).actRight ▷ P.X) ((α_ (regular R).X R.X P.X).hom ≫ (regular R).X ◁ P.actLeft) ≫
      𝟙 (coequalizer ((regular R).actRight ▷ P.X) ((α_ (regular R).X R.X P.X).hom ≫ (regular R).X ◁ P.actLeft))

tactic: dsimp
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝ : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
⊢ coequalizer.π ((regular R).actRight ▷ P.X) ((α_ (regular R).X R.X P.X).hom ≫ (regular R).X ◁ P.actLeft) ≫
      coequalizer.desc P.actLeft ⋯ ≫
        (λ_ P.X).inv ≫
          R.one ▷ P.X ≫
            coequalizer.π ((regular R).actRight ▷ P.X) ((α_ (regular R).X R.X P.X).hom ≫ (regular R).X ◁ P.actLeft) =
    coequalizer.π ((regular R).actRight ▷ P.X) ((α_ (regular R).X R.X P.X).hom ≫ (regular R).X ◁ P.actLeft) ≫
      𝟙 (coequalizer ((regular R).actRight ▷ P.X) ((α_ (regular R).X R.X P.X).hom ≫ (regular R).X ◁ P.actLeft))
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝ : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
⊢ coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) ≫
      coequalizer.desc P.actLeft ⋯ ≫
        (λ_ P.X).inv ≫ R.one ▷ P.X ≫ coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) =
    coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) ≫
      𝟙 (coequalizer (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft))

tactic: slice_lhs 1 2 => rw [coequalizer.π_desc]
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝ : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
⊢ coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) ≫
      coequalizer.desc P.actLeft ⋯ ≫
        (λ_ P.X).inv ≫ R.one ▷ P.X ≫ coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) =
    coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) ≫
      𝟙 (coequalizer (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft))
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝ : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
⊢ ((P.actLeft ≫ (λ_ P.X).inv) ≫ R.one ▷ P.X) ≫ coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) =
    coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) ≫
      𝟙 (coequalizer (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft))

tactic: slice_lhs 1 2 => rw [leftUnitor_inv_naturality]
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝ : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
⊢ ((P.actLeft ≫ (λ_ P.X).inv) ≫ R.one ▷ P.X) ≫ coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) =
    coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) ≫
      𝟙 (coequalizer (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft))
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝ : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
⊢ (((λ_ (R.X ⊗ P.X)).inv ≫ 𝟙_ C ◁ P.actLeft) ≫ R.one ▷ P.X) ≫
      coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) =
    coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) ≫
      𝟙 (coequalizer (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft))

tactic: slice_lhs 2 3 => rw [whisker_exchange]
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝ : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
⊢ (((λ_ (R.X ⊗ P.X)).inv ≫ 𝟙_ C ◁ P.actLeft) ≫ R.one ▷ P.X) ≫
      coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) =
    coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) ≫
      𝟙 (coequalizer (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft))
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝ : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
⊢ (λ_ (R.X ⊗ P.X)).inv ≫
      (R.one ▷ (R.X ⊗ P.X) ≫ R.X ◁ P.actLeft) ≫ coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) =
    coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) ≫
      𝟙 (coequalizer (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft))

tactic: slice_lhs 3 3 => rw [← Iso.inv_hom_id_assoc (α_ R.X R.X P.X) (R.X ◁ P.actLeft)]
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝ : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
⊢ (λ_ (R.X ⊗ P.X)).inv ≫
      (R.one ▷ (R.X ⊗ P.X) ≫ R.X ◁ P.actLeft) ≫ coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) =
    coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) ≫
      𝟙 (coequalizer (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft))
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝ : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
⊢ (λ_ (R.X ⊗ P.X)).inv ≫
      R.one ▷ (R.X ⊗ P.X) ≫
        ((α_ R.X R.X P.X).inv ≫ (α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) ≫
          coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) =
    coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) ≫
      𝟙 (coequalizer (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft))

tactic: slice_lhs 4 6 => rw [← Category.assoc, ← coequalizer.condition]
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝ : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
⊢ (λ_ (R.X ⊗ P.X)).inv ≫
      R.one ▷ (R.X ⊗ P.X) ≫
        ((α_ R.X R.X P.X).inv ≫ (α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) ≫
          coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) =
    coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) ≫
      𝟙 (coequalizer (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft))
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝ : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
⊢ (λ_ (R.X ⊗ P.X)).inv ≫
      R.one ▷ (R.X ⊗ P.X) ≫
        (α_ R.X R.X P.X).inv ≫ R.mul ▷ P.X ≫ coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) =
    coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) ≫
      𝟙 (coequalizer (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft))

tactic: slice_lhs 2 3 => rw [associator_inv_naturality_left]
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝ : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
⊢ (λ_ (R.X ⊗ P.X)).inv ≫
      R.one ▷ (R.X ⊗ P.X) ≫
        (α_ R.X R.X P.X).inv ≫ R.mul ▷ P.X ≫ coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) =
    coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) ≫
      𝟙 (coequalizer (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft))
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝ : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
⊢ (λ_ (R.X ⊗ P.X)).inv ≫
      (((α_ (𝟙_ C) R.X P.X).inv ≫ R.one ▷ R.X ▷ P.X) ≫ R.mul ▷ P.X) ≫
        coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) =
    coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) ≫
      𝟙 (coequalizer (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft))

tactic: slice_lhs 3 4 => rw [← comp_whiskerRight, Mon_.one_mul]
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝ : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
⊢ (λ_ (R.X ⊗ P.X)).inv ≫
      (((α_ (𝟙_ C) R.X P.X).inv ≫ R.one ▷ R.X ▷ P.X) ≫ R.mul ▷ P.X) ≫
        coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) =
    coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) ≫
      𝟙 (coequalizer (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft))
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝ : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
⊢ (λ_ (R.X ⊗ P.X)).inv ≫
      (α_ (𝟙_ C) R.X P.X).inv ≫
        (λ_ R.X).hom ▷ P.X ≫ coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) =
    coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) ≫
      𝟙 (coequalizer (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft))

tactic: slice_rhs 1 2 => rw [Category.comp_id]
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝ : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
⊢ (λ_ (R.X ⊗ P.X)).inv ≫
      (α_ (𝟙_ C) R.X P.X).inv ≫
        (λ_ R.X).hom ▷ P.X ≫ coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) =
    coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) ≫
      𝟙 (coequalizer (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft))
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝ : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
⊢ (λ_ (R.X ⊗ P.X)).inv ≫
      (α_ (𝟙_ C) R.X P.X).inv ≫
        (λ_ R.X).hom ▷ P.X ≫ coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) =
    coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft)

tactic: coherence
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝ : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
⊢ (λ_ (R.X ⊗ P.X)).inv ≫
      (α_ (𝟙_ C) R.X P.X).inv ≫
        (λ_ R.X).hom ▷ P.X ≫ coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft) =
    coequalizer.π (R.mul ▷ P.X) ((α_ R.X R.X P.X).hom ≫ R.X ◁ P.actLeft)
state_after: no goals