l3lab/ntp-mathlib huggingface dataset:
/-- `reverse` acts only on the right of the tensor product. -/
theorem toBaseChange_reverse (Q : QuadraticForm R V) (x : CliffordAlgebra (Q.baseChange A)) :
    toBaseChange A Q (reverse x) =
      TensorProduct.map LinearMap.id reverse (toBaseChange A Q x) := by
  

Proof state:
R : Type u_1
A : Type u_2
V : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : AddCommGroup V
inst✝⁴ : Algebra R A
inst✝³ : Module R V
inst✝² : Module A V
inst✝¹ : IsScalarTower R A V
inst✝ : Invertible 2
Q : QuadraticForm R V
x : CliffordAlgebra (QuadraticForm.baseChange A Q)
⊢ (toBaseChange A Q) (reverse x) = (TensorProduct.map LinearMap.id reverse) ((toBaseChange A Q) x)

Next tactic:
have := FunLike.congr_fun (toBaseChange_comp_reverseOp A Q) x
/-- `reverse` acts only on the right of the tensor product. -/
theorem toBaseChange_reverse (Q : QuadraticForm R V) (x : CliffordAlgebra (Q.baseChange A)) :
    toBaseChange A Q (reverse x) =
      TensorProduct.map LinearMap.id reverse (toBaseChange A Q x) := by
  have := FunLike.congr_fun (toBaseChange_comp_reverseOp A Q) x
  

Proof state:
R : Type u_1
A : Type u_2
V : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : AddCommGroup V
inst✝⁴ : Algebra R A
inst✝³ : Module R V
inst✝² : Module A V
inst✝¹ : IsScalarTower R A V
inst✝ : Invertible 2
Q : QuadraticForm R V
x : CliffordAlgebra (QuadraticForm.baseChange A Q)
this :
  (AlgHom.comp (AlgHom.op (toBaseChange A Q)) reverseOp) x =
    (AlgHom.comp (↑(Algebra.TensorProduct.opAlgEquiv R A A (CliffordAlgebra Q)))
        (AlgHom.comp (Algebra.TensorProduct.map (↑(AlgEquiv.toOpposite A A)) reverseOp) (toBaseChange A Q)))
      x
⊢ (toBaseChange A Q) (reverse x) = (TensorProduct.map LinearMap.id reverse) ((toBaseChange A Q) x)

Next tactic:
refine (congr_arg unop this).trans ?_
/-- `reverse` acts only on the right of the tensor product. -/
theorem toBaseChange_reverse (Q : QuadraticForm R V) (x : CliffordAlgebra (Q.baseChange A)) :
    toBaseChange A Q (reverse x) =
      TensorProduct.map LinearMap.id reverse (toBaseChange A Q x) := by
  have := FunLike.congr_fun (toBaseChange_comp_reverseOp A Q) x
  refine (congr_arg unop this).trans ?_; 

Proof state:
R : Type u_1
A : Type u_2
V : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : AddCommGroup V
inst✝⁴ : Algebra R A
inst✝³ : Module R V
inst✝² : Module A V
inst✝¹ : IsScalarTower R A V
inst✝ : Invertible 2
Q : QuadraticForm R V
x : CliffordAlgebra (QuadraticForm.baseChange A Q)
this :
  (AlgHom.comp (AlgHom.op (toBaseChange A Q)) reverseOp) x =
    (AlgHom.comp (↑(Algebra.TensorProduct.opAlgEquiv R A A (CliffordAlgebra Q)))
        (AlgHom.comp (Algebra.TensorProduct.map (↑(AlgEquiv.toOpposite A A)) reverseOp) (toBaseChange A Q)))
      x
⊢ unop
      ((AlgHom.comp (↑(Algebra.TensorProduct.opAlgEquiv R A A (CliffordAlgebra Q)))
          (AlgHom.comp (Algebra.TensorProduct.map (↑(AlgEquiv.toOpposite A A)) reverseOp) (toBaseChange A Q)))
        x) =
    (TensorProduct.map LinearMap.id reverse) ((toBaseChange A Q) x)

Next tactic:
clear this
/-- `reverse` acts only on the right of the tensor product. -/
theorem toBaseChange_reverse (Q : QuadraticForm R V) (x : CliffordAlgebra (Q.baseChange A)) :
    toBaseChange A Q (reverse x) =
      TensorProduct.map LinearMap.id reverse (toBaseChange A Q x) := by
  have := FunLike.congr_fun (toBaseChange_comp_reverseOp A Q) x
  refine (congr_arg unop this).trans ?_; clear this
  

Proof state:
R : Type u_1
A : Type u_2
V : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : AddCommGroup V
inst✝⁴ : Algebra R A
inst✝³ : Module R V
inst✝² : Module A V
inst✝¹ : IsScalarTower R A V
inst✝ : Invertible 2
Q : QuadraticForm R V
x : CliffordAlgebra (QuadraticForm.baseChange A Q)
⊢ unop
      ((AlgHom.comp (↑(Algebra.TensorProduct.opAlgEquiv R A A (CliffordAlgebra Q)))
          (AlgHom.comp (Algebra.TensorProduct.map (↑(AlgEquiv.toOpposite A A)) reverseOp) (toBaseChange A Q)))
        x) =
    (TensorProduct.map LinearMap.id reverse) ((toBaseChange A Q) x)

Next tactic:
refine (LinearMap.congr_fun (TensorProduct.AlgebraTensorModule.map_comp _ _ _ _).symm _).trans ?_
/-- `reverse` acts only on the right of the tensor product. -/
theorem toBaseChange_reverse (Q : QuadraticForm R V) (x : CliffordAlgebra (Q.baseChange A)) :
    toBaseChange A Q (reverse x) =
      TensorProduct.map LinearMap.id reverse (toBaseChange A Q x) := by
  have := FunLike.congr_fun (toBaseChange_comp_reverseOp A Q) x
  refine (congr_arg unop this).trans ?_; clear this
  refine (LinearMap.congr_fun (TensorProduct.AlgebraTensorModule.map_comp _ _ _ _).symm _).trans ?_
  

Proof state:
R : Type u_1
A : Type u_2
V : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : AddCommGroup V
inst✝⁴ : Algebra R A
inst✝³ : Module R V
inst✝² : Module A V
inst✝¹ : IsScalarTower R A V
inst✝ : Invertible 2
Q : QuadraticForm R V
x : CliffordAlgebra (QuadraticForm.baseChange A Q)
⊢ (TensorProduct.AlgebraTensorModule.map
        (↑(LinearEquiv.symm (opLinearEquiv A)) ∘ₗ AlgHom.toLinearMap ↑(AlgEquiv.toOpposite A A))
        (↑(LinearEquiv.symm (opLinearEquiv R)) ∘ₗ AlgHom.toLinearMap reverseOp))
      (↑(toBaseChange A Q) x) =
    (TensorProduct.map LinearMap.id reverse) ((toBaseChange A Q) x)

Next tactic:
rw [reverse, ← AlgEquiv.toLinearMap, ← AlgEquiv.toLinearEquiv_toLinearMap,
    AlgEquiv.toLinearEquiv_toOpposite]
/-- `reverse` acts only on the right of the tensor product. -/
theorem toBaseChange_reverse (Q : QuadraticForm R V) (x : CliffordAlgebra (Q.baseChange A)) :
    toBaseChange A Q (reverse x) =
      TensorProduct.map LinearMap.id reverse (toBaseChange A Q x) := by
  have := FunLike.congr_fun (toBaseChange_comp_reverseOp A Q) x
  refine (congr_arg unop this).trans ?_; clear this
  refine (LinearMap.congr_fun (TensorProduct.AlgebraTensorModule.map_comp _ _ _ _).symm _).trans ?_
  rw [reverse, ← AlgEquiv.toLinearMap, ← AlgEquiv.toLinearEquiv_toLinearMap,
    AlgEquiv.toLinearEquiv_toOpposite]
  

Proof state:
R : Type u_1
A : Type u_2
V : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : AddCommGroup V
inst✝⁴ : Algebra R A
inst✝³ : Module R V
inst✝² : Module A V
inst✝¹ : IsScalarTower R A V
inst✝ : Invertible 2
Q : QuadraticForm R V
x : CliffordAlgebra (QuadraticForm.baseChange A Q)
⊢ (TensorProduct.AlgebraTensorModule.map (↑(LinearEquiv.symm (opLinearEquiv A)) ∘ₗ ↑(opLinearEquiv A))
        (↑(LinearEquiv.symm (opLinearEquiv R)) ∘ₗ AlgHom.toLinearMap reverseOp))
      (↑(toBaseChange A Q) x) =
    (TensorProduct.map LinearMap.id
        (LinearMap.comp (↑(LinearEquiv.symm (opLinearEquiv R))) (AlgHom.toLinearMap reverseOp)))
      ((toBaseChange A Q) x)

Next tactic:
dsimp
/-- `reverse` acts only on the right of the tensor product. -/
theorem toBaseChange_reverse (Q : QuadraticForm R V) (x : CliffordAlgebra (Q.baseChange A)) :
    toBaseChange A Q (reverse x) =
      TensorProduct.map LinearMap.id reverse (toBaseChange A Q x) := by
  have := FunLike.congr_fun (toBaseChange_comp_reverseOp A Q) x
  refine (congr_arg unop this).trans ?_; clear this
  refine (LinearMap.congr_fun (TensorProduct.AlgebraTensorModule.map_comp _ _ _ _).symm _).trans ?_
  rw [reverse, ← AlgEquiv.toLinearMap, ← AlgEquiv.toLinearEquiv_toLinearMap,
    AlgEquiv.toLinearEquiv_toOpposite]
  dsimp
  -- `simp` fails here due to a timeout looking for a `Subsingleton` instance!?
  

Proof state:
R : Type u_1
A : Type u_2
V : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : AddCommGroup V
inst✝⁴ : Algebra R A
inst✝³ : Module R V
inst✝² : Module A V
inst✝¹ : IsScalarTower R A V
inst✝ : Invertible 2
Q : QuadraticForm R V
x : CliffordAlgebra (QuadraticForm.baseChange A Q)
⊢ (TensorProduct.AlgebraTensorModule.map (↑(opLinearEquiv A ≪≫ₗ LinearEquiv.symm (opLinearEquiv A)))
        (↑(LinearEquiv.symm (opLinearEquiv R)) ∘ₗ AlgHom.toLinearMap reverseOp))
      ((toBaseChange A Q) x) =
    (TensorProduct.map LinearMap.id
        (LinearMap.comp (↑(LinearEquiv.symm (opLinearEquiv R))) (AlgHom.toLinearMap reverseOp)))
      ((toBaseChange A Q) x)

Next tactic:
rw [LinearEquiv.self_trans_symm]
/-- `reverse` acts only on the right of the tensor product. -/
theorem toBaseChange_reverse (Q : QuadraticForm R V) (x : CliffordAlgebra (Q.baseChange A)) :
    toBaseChange A Q (reverse x) =
      TensorProduct.map LinearMap.id reverse (toBaseChange A Q x) := by
  have := FunLike.congr_fun (toBaseChange_comp_reverseOp A Q) x
  refine (congr_arg unop this).trans ?_; clear this
  refine (LinearMap.congr_fun (TensorProduct.AlgebraTensorModule.map_comp _ _ _ _).symm _).trans ?_
  rw [reverse, ← AlgEquiv.toLinearMap, ← AlgEquiv.toLinearEquiv_toLinearMap,
    AlgEquiv.toLinearEquiv_toOpposite]
  dsimp
  -- `simp` fails here due to a timeout looking for a `Subsingleton` instance!?
  rw [LinearEquiv.self_trans_symm]
  

Proof state:
R : Type u_1
A : Type u_2
V : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : AddCommGroup V
inst✝⁴ : Algebra R A
inst✝³ : Module R V
inst✝² : Module A V
inst✝¹ : IsScalarTower R A V
inst✝ : Invertible 2
Q : QuadraticForm R V
x : CliffordAlgebra (QuadraticForm.baseChange A Q)
⊢ (TensorProduct.AlgebraTensorModule.map (↑(LinearEquiv.refl A A))
        (↑(LinearEquiv.symm (opLinearEquiv R)) ∘ₗ AlgHom.toLinearMap reverseOp))
      ((toBaseChange A Q) x) =
    (TensorProduct.map LinearMap.id
        (LinearMap.comp (↑(LinearEquiv.symm (opLinearEquiv R))) (AlgHom.toLinearMap reverseOp)))
      ((toBaseChange A Q) x)

Next tactic:
rfl
theorem toBaseChange_comp_ofBaseChange (Q : QuadraticForm R V) :
    (toBaseChange A Q).comp (ofBaseChange A Q) = AlgHom.id _ _ := by
  

Proof state:
R : Type u_1
A : Type u_2
V : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : AddCommGroup V
inst✝⁴ : Algebra R A
inst✝³ : Module R V
inst✝² : Module A V
inst✝¹ : IsScalarTower R A V
inst✝ : Invertible 2
Q : QuadraticForm R V
⊢ AlgHom.comp (toBaseChange A Q) (ofBaseChange A Q) = AlgHom.id A (A ⊗[R] CliffordAlgebra Q)

Next tactic:
ext v
theorem toBaseChange_comp_ofBaseChange (Q : QuadraticForm R V) :
    (toBaseChange A Q).comp (ofBaseChange A Q) = AlgHom.id _ _ := by
  ext v
  

Proof state:
case hb.a.h
R : Type u_1
A : Type u_2
V : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : AddCommGroup V
inst✝⁴ : Algebra R A
inst✝³ : Module R V
inst✝² : Module A V
inst✝¹ : IsScalarTower R A V
inst✝ : Invertible 2
Q : QuadraticForm R V
v : V
⊢ (AlgHom.toLinearMap
          (AlgHom.comp (AlgHom.restrictScalars R (AlgHom.comp (toBaseChange A Q) (ofBaseChange A Q)))
            Algebra.TensorProduct.includeRight) ∘ₗ
        ι Q)
      v =
    (AlgHom.toLinearMap
          (AlgHom.comp (AlgHom.restrictScalars R (AlgHom.id A (A ⊗[R] CliffordAlgebra Q)))
            Algebra.TensorProduct.includeRight) ∘ₗ
        ι Q)
      v

Next tactic:
change toBaseChange A Q (ofBaseChange A Q (1 ⊗ₜ[R] ι Q v)) = 1 ⊗ₜ[R] ι Q v
theorem toBaseChange_comp_ofBaseChange (Q : QuadraticForm R V) :
    (toBaseChange A Q).comp (ofBaseChange A Q) = AlgHom.id _ _ := by
  ext v
  change toBaseChange A Q (ofBaseChange A Q (1 ⊗ₜ[R] ι Q v)) = 1 ⊗ₜ[R] ι Q v
  

Proof state:
case hb.a.h
R : Type u_1
A : Type u_2
V : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : AddCommGroup V
inst✝⁴ : Algebra R A
inst✝³ : Module R V
inst✝² : Module A V
inst✝¹ : IsScalarTower R A V
inst✝ : Invertible 2
Q : QuadraticForm R V
v : V
⊢ (toBaseChange A Q) ((ofBaseChange A Q) (1 ⊗ₜ[R] (ι Q) v)) = 1 ⊗ₜ[R] (ι Q) v

Next tactic:
rw [ofBaseChange_tmul_ι, toBaseChange_ι]
theorem ofBaseChange_comp_toBaseChange (Q : QuadraticForm R V) :
    (ofBaseChange A Q).comp (toBaseChange A Q) = AlgHom.id _ _ := by
  

Proof state:
R : Type u_1
A : Type u_2
V : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : AddCommGroup V
inst✝⁴ : Algebra R A
inst✝³ : Module R V
inst✝² : Module A V
inst✝¹ : IsScalarTower R A V
inst✝ : Invertible 2
Q : QuadraticForm R V
⊢ AlgHom.comp (ofBaseChange A Q) (toBaseChange A Q) = AlgHom.id A (CliffordAlgebra (QuadraticForm.baseChange A Q))

Next tactic:
ext x
theorem ofBaseChange_comp_toBaseChange (Q : QuadraticForm R V) :
    (ofBaseChange A Q).comp (toBaseChange A Q) = AlgHom.id _ _ := by
  ext x
  

Proof state:
case a.a.h.h
R : Type u_1
A : Type u_2
V : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : AddCommGroup V
inst✝⁴ : Algebra R A
inst✝³ : Module R V
inst✝² : Module A V
inst✝¹ : IsScalarTower R A V
inst✝ : Invertible 2
Q : QuadraticForm R V
x : V
⊢ ((TensorProduct.AlgebraTensorModule.curry
          (AlgHom.toLinearMap (AlgHom.comp (ofBaseChange A Q) (toBaseChange A Q)) ∘ₗ ι (QuadraticForm.baseChange A Q)))
        1)
      x =
    ((TensorProduct.AlgebraTensorModule.curry
          (AlgHom.toLinearMap (AlgHom.id A (CliffordAlgebra (QuadraticForm.baseChange A Q))) ∘ₗ
            ι (QuadraticForm.baseChange A Q)))
        1)
      x

Next tactic:
show ofBaseChange A Q (toBaseChange A Q (ι (Q.baseChange A) (1 ⊗ₜ[R] x)))
    = ι (Q.baseChange A) (1 ⊗ₜ[R] x)
theorem ofBaseChange_comp_toBaseChange (Q : QuadraticForm R V) :
    (ofBaseChange A Q).comp (toBaseChange A Q) = AlgHom.id _ _ := by
  ext x
  show ofBaseChange A Q (toBaseChange A Q (ι (Q.baseChange A) (1 ⊗ₜ[R] x)))
    = ι (Q.baseChange A) (1 ⊗ₜ[R] x)
  

Proof state:
case a.a.h.h
R : Type u_1
A : Type u_2
V : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : AddCommGroup V
inst✝⁴ : Algebra R A
inst✝³ : Module R V
inst✝² : Module A V
inst✝¹ : IsScalarTower R A V
inst✝ : Invertible 2
Q : QuadraticForm R V
x : V
⊢ (ofBaseChange A Q) ((toBaseChange A Q) ((ι (QuadraticForm.baseChange A Q)) (1 ⊗ₜ[R] x))) =
    (ι (QuadraticForm.baseChange A Q)) (1 ⊗ₜ[R] x)

Next tactic:
rw [toBaseChange_ι, ofBaseChange_tmul_ι]
/-- Tensoring on the right gives a monoidal functor from `C` into endofunctors of `C`.
-/
@[simps!]
def tensoringRightMonoidal [MonoidalCategory.{v} C] : MonoidalFunctor C (C ⥤ C) :=
  { tensoringRight C with
    ε := (rightUnitorNatIso C).inv
    μ := fun X Y => { app := fun Z => (α_ Z X Y).hom }
    μ_natural := fun f g => by
      

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
src✝ : C ⥤ C ⥤ C := tensoringRight C
X✝ Y✝ X'✝ Y'✝ : C
f : X✝ ⟶ Y✝
g : X'✝ ⟶ Y'✝
⊢ ((Functor.mk src✝.toPrefunctor).map f ⊗ (Functor.mk src✝.toPrefunctor).map g) ≫
      (fun X Y => NatTrans.mk fun Z => (α_ Z X Y).hom) Y✝ Y'✝ =
    (fun X Y => NatTrans.mk fun Z => (α_ Z X Y).hom) X✝ X'✝ ≫ (Functor.mk src✝.toPrefunctor).map (f ⊗ g)

Next tactic:
ext Z
/-- Tensoring on the right gives a monoidal functor from `C` into endofunctors of `C`.
-/
@[simps!]
def tensoringRightMonoidal [MonoidalCategory.{v} C] : MonoidalFunctor C (C ⥤ C) :=
  { tensoringRight C with
    ε := (rightUnitorNatIso C).inv
    μ := fun X Y => { app := fun Z => (α_ Z X Y).hom }
    μ_natural := fun f g => by
      ext Z
      

Proof state:
case w.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
src✝ : C ⥤ C ⥤ C := tensoringRight C
X✝ Y✝ X'✝ Y'✝ : C
f : X✝ ⟶ Y✝
g : X'✝ ⟶ Y'✝
Z : C
⊢ (((Functor.mk src✝.toPrefunctor).map f ⊗ (Functor.mk src✝.toPrefunctor).map g) ≫
          (fun X Y => NatTrans.mk fun Z => (α_ Z X Y).hom) Y✝ Y'✝).app
      Z =
    ((fun X Y => NatTrans.mk fun Z => (α_ Z X Y).hom) X✝ X'✝ ≫ (Functor.mk src✝.toPrefunctor).map (f ⊗ g)).app Z

Next tactic:
dsimp
/-- Tensoring on the right gives a monoidal functor from `C` into endofunctors of `C`.
-/
@[simps!]
def tensoringRightMonoidal [MonoidalCategory.{v} C] : MonoidalFunctor C (C ⥤ C) :=
  { tensoringRight C with
    ε := (rightUnitorNatIso C).inv
    μ := fun X Y => { app := fun Z => (α_ Z X Y).hom }
    μ_natural := fun f g => by
      ext Z
      dsimp
      

Proof state:
case w.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
src✝ : C ⥤ C ⥤ C := tensoringRight C
X✝ Y✝ X'✝ Y'✝ : C
f : X✝ ⟶ Y✝
g : X'✝ ⟶ Y'✝
Z : C
⊢ ((𝟙 (Z ⊗ X✝) ⊗ g) ≫ ((𝟙 Z ⊗ f) ⊗ 𝟙 Y'✝)) ≫ (α_ Z Y✝ Y'✝).hom = (α_ Z X✝ X'✝).hom ≫ (𝟙 Z ⊗ f ⊗ g)

Next tactic:
simp only [← id_tensor_comp_tensor_id g f, id_tensor_comp, ← tensor_id, Category.assoc,
        associator_naturality, associator_naturality_assoc]
/-- Tensoring on the right gives a monoidal functor from `C` into endofunctors of `C`.
-/
@[simps!]
def tensoringRightMonoidal [MonoidalCategory.{v} C] : MonoidalFunctor C (C ⥤ C) :=
  { tensoringRight C with
    ε := (rightUnitorNatIso C).inv
    μ := fun X Y => { app := fun Z => (α_ Z X Y).hom }
    μ_natural := fun f g => by
      ext Z
      dsimp
      simp only [← id_tensor_comp_tensor_id g f, id_tensor_comp, ← tensor_id, Category.assoc,
        associator_naturality, associator_naturality_assoc]
    associativity := fun X Y Z => by
      

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
src✝ : C ⥤ C ⥤ C := tensoringRight C
X Y Z : C
⊢ ((fun X Y => NatTrans.mk fun Z => (α_ Z X Y).hom) X Y ⊗ 𝟙 ((Functor.mk src✝.toPrefunctor).obj Z)) ≫
      (fun X Y => NatTrans.mk fun Z => (α_ Z X Y).hom) (X ⊗ Y) Z ≫ (Functor.mk src✝.toPrefunctor).map (α_ X Y Z).hom =
    (α_ ((Functor.mk src✝.toPrefunctor).obj X) ((Functor.mk src✝.toPrefunctor).obj Y)
          ((Functor.mk src✝.toPrefunctor).obj Z)).hom ≫
      (𝟙 ((Functor.mk src✝.toPrefunctor).obj X) ⊗ (fun X Y => NatTrans.mk fun Z => (α_ Z X Y).hom) Y Z) ≫
        (fun X Y => NatTrans.mk fun Z => (α_ Z X Y).hom) X (Y ⊗ Z)

Next tactic:
ext W
/-- Tensoring on the right gives a monoidal functor from `C` into endofunctors of `C`.
-/
@[simps!]
def tensoringRightMonoidal [MonoidalCategory.{v} C] : MonoidalFunctor C (C ⥤ C) :=
  { tensoringRight C with
    ε := (rightUnitorNatIso C).inv
    μ := fun X Y => { app := fun Z => (α_ Z X Y).hom }
    μ_natural := fun f g => by
      ext Z
      dsimp
      simp only [← id_tensor_comp_tensor_id g f, id_tensor_comp, ← tensor_id, Category.assoc,
        associator_naturality, associator_naturality_assoc]
    associativity := fun X Y Z => by
      ext W
      

Proof state:
case w.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
src✝ : C ⥤ C ⥤ C := tensoringRight C
X Y Z W : C
⊢ (((fun X Y => NatTrans.mk fun Z => (α_ Z X Y).hom) X Y ⊗ 𝟙 ((Functor.mk src✝.toPrefunctor).obj Z)) ≫
          (fun X Y => NatTrans.mk fun Z => (α_ Z X Y).hom) (X ⊗ Y) Z ≫
            (Functor.mk src✝.toPrefunctor).map (α_ X Y Z).hom).app
      W =
    ((α_ ((Functor.mk src✝.toPrefunctor).obj X) ((Functor.mk src✝.toPrefunctor).obj Y)
              ((Functor.mk src✝.toPrefunctor).obj Z)).hom ≫
          (𝟙 ((Functor.mk src✝.toPrefunctor).obj X) ⊗ (fun X Y => NatTrans.mk fun Z => (α_ Z X Y).hom) Y Z) ≫
            (fun X Y => NatTrans.mk fun Z => (α_ Z X Y).hom) X (Y ⊗ Z)).app
      W

Next tactic:
simp [pentagon]
/-- Tensoring on the right gives a monoidal functor from `C` into endofunctors of `C`.
-/
@[simps!]
def tensoringRightMonoidal [MonoidalCategory.{v} C] : MonoidalFunctor C (C ⥤ C) :=
  { tensoringRight C with
    ε := (rightUnitorNatIso C).inv
    μ := fun X Y => { app := fun Z => (α_ Z X Y).hom }
    μ_natural := fun f g => by
      ext Z
      dsimp
      simp only [← id_tensor_comp_tensor_id g f, id_tensor_comp, ← tensor_id, Category.assoc,
        associator_naturality, associator_naturality_assoc]
    associativity := fun X Y Z => by
      ext W
      simp [pentagon]
    μ_isIso := fun X Y =>
      -- We could avoid needing to do this explicitly by
      -- constructing a partially applied analogue of `associatorNatIso`.
      ⟨⟨{ app := fun Z => (α_ Z X Y).inv
          naturality := fun Z Z' f => by
            

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
src✝ : C ⥤ C ⥤ C := tensoringRight C
X Y Z Z' : C
f : Z ⟶ Z'
⊢ ((LaxMonoidalFunctor.mk (Functor.mk src✝.toPrefunctor) (rightUnitorNatIso C).inv fun X Y =>
                  NatTrans.mk fun Z => (α_ Z X Y).hom).toFunctor.obj
            (X ⊗ Y)).map
        f ≫
      (fun Z => (α_ Z X Y).inv) Z' =
    (fun Z => (α_ Z X Y).inv) Z ≫
      ((LaxMonoidalFunctor.mk (Functor.mk src✝.toPrefunctor) (rightUnitorNatIso C).inv fun X Y =>
                    NatTrans.mk fun Z => (α_ Z X Y).hom).toFunctor.obj
              X ⊗
            (LaxMonoidalFunctor.mk (Functor.mk src✝.toPrefunctor) (rightUnitorNatIso C).inv fun X Y =>
                    NatTrans.mk fun Z => (α_ Z X Y).hom).toFunctor.obj
              Y).map
        f

Next tactic:
dsimp
/-- Tensoring on the right gives a monoidal functor from `C` into endofunctors of `C`.
-/
@[simps!]
def tensoringRightMonoidal [MonoidalCategory.{v} C] : MonoidalFunctor C (C ⥤ C) :=
  { tensoringRight C with
    ε := (rightUnitorNatIso C).inv
    μ := fun X Y => { app := fun Z => (α_ Z X Y).hom }
    μ_natural := fun f g => by
      ext Z
      dsimp
      simp only [← id_tensor_comp_tensor_id g f, id_tensor_comp, ← tensor_id, Category.assoc,
        associator_naturality, associator_naturality_assoc]
    associativity := fun X Y Z => by
      ext W
      simp [pentagon]
    μ_isIso := fun X Y =>
      -- We could avoid needing to do this explicitly by
      -- constructing a partially applied analogue of `associatorNatIso`.
      ⟨⟨{ app := fun Z => (α_ Z X Y).inv
          naturality := fun Z Z' f => by
            dsimp
            

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
src✝ : C ⥤ C ⥤ C := tensoringRight C
X Y Z Z' : C
f : Z ⟶ Z'
⊢ (f ⊗ 𝟙 (X ⊗ Y)) ≫ (α_ Z' X Y).inv = (α_ Z X Y).inv ≫ ((f ⊗ 𝟙 X) ⊗ 𝟙 Y)

Next tactic:
rw [← associator_inv_naturality]
/-- Tensoring on the right gives a monoidal functor from `C` into endofunctors of `C`.
-/
@[simps!]
def tensoringRightMonoidal [MonoidalCategory.{v} C] : MonoidalFunctor C (C ⥤ C) :=
  { tensoringRight C with
    ε := (rightUnitorNatIso C).inv
    μ := fun X Y => { app := fun Z => (α_ Z X Y).hom }
    μ_natural := fun f g => by
      ext Z
      dsimp
      simp only [← id_tensor_comp_tensor_id g f, id_tensor_comp, ← tensor_id, Category.assoc,
        associator_naturality, associator_naturality_assoc]
    associativity := fun X Y Z => by
      ext W
      simp [pentagon]
    μ_isIso := fun X Y =>
      -- We could avoid needing to do this explicitly by
      -- constructing a partially applied analogue of `associatorNatIso`.
      ⟨⟨{ app := fun Z => (α_ Z X Y).inv
          naturality := fun Z Z' f => by
            dsimp
            rw [← associator_inv_naturality]
            

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
src✝ : C ⥤ C ⥤ C := tensoringRight C
X Y Z Z' : C
f : Z ⟶ Z'
⊢ (f ⊗ 𝟙 (X ⊗ Y)) ≫ (α_ Z' X Y).inv = (f ⊗ 𝟙 X ⊗ 𝟙 Y) ≫ (α_ Z' X Y).inv

Next tactic:
simp