Theorem: ModuleCat.Free.μ_natural
File: Mathlib/Algebra/Category/ModuleCat/Adjunctions.lean

tactic: intros
state_before: R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
⊢ ((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom = (μ R X X').hom ≫ (free R).map (f ⊗ g)

tactic: apply TensorProduct.ext
state_before: R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
⊢ ((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom = (μ R X X').hom ≫ (free R).map (f ⊗ g)

tactic: apply Finsupp.lhom_ext'
state_before: case H
R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
⊢ LinearMap.compr₂ (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X'))
      (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) =
    LinearMap.compr₂ (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')) ((μ R X X').hom ≫ (free R).map (f ⊗ g))

tactic: intro x
state_before: case H.h
R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
⊢ ∀ (a : X),
    LinearMap.comp
        (LinearMap.compr₂ (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X'))
          (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom))
        (Finsupp.lsingle a) =
      LinearMap.comp
        (LinearMap.compr₂ (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X'))
          ((μ R X X').hom ≫ (free R).map (f ⊗ g)))
        (Finsupp.lsingle a)

tactic: apply LinearMap.ext_ring
state_before: case H.h
R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
x : X
⊢ LinearMap.comp
      (LinearMap.compr₂ (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X'))
        (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom))
      (Finsupp.lsingle x) =
    LinearMap.comp
      (LinearMap.compr₂ (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X'))
        ((μ R X X').hom ≫ (free R).map (f ⊗ g)))
      (Finsupp.lsingle x)

tactic: apply Finsupp.lhom_ext'
state_before: case H.h.h
R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
x : X
⊢ ↑(LinearMap.comp
          (LinearMap.compr₂ (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X'))
            (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom))
          (Finsupp.lsingle x))
      1 =
    ↑(LinearMap.comp
          (LinearMap.compr₂ (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X'))
            ((μ R X X').hom ≫ (free R).map (f ⊗ g)))
          (Finsupp.lsingle x))
      1

tactic: intro x'
state_before: case H.h.h.h
R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
x : X
⊢ ∀ (a : X'),
    LinearMap.comp
        (↑(LinearMap.comp
              (LinearMap.compr₂ (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X'))
                (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom))
              (Finsupp.lsingle x))
          1)
        (Finsupp.lsingle a) =
      LinearMap.comp
        (↑(LinearMap.comp
              (LinearMap.compr₂ (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X'))
                ((μ R X X').hom ≫ (free R).map (f ⊗ g)))
              (Finsupp.lsingle x))
          1)
        (Finsupp.lsingle a)

tactic: apply LinearMap.ext_ring
state_before: case H.h.h.h
R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
x : X
x' : X'
⊢ LinearMap.comp
      (↑(LinearMap.comp
            (LinearMap.compr₂ (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X'))
              (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom))
            (Finsupp.lsingle x))
        1)
      (Finsupp.lsingle x') =
    LinearMap.comp
      (↑(LinearMap.comp
            (LinearMap.compr₂ (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X'))
              ((μ R X X').hom ≫ (free R).map (f ⊗ g)))
            (Finsupp.lsingle x))
        1)
      (Finsupp.lsingle x')

tactic: apply Finsupp.ext
state_before: case H.h.h.h.h
R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
x : X
x' : X'
⊢ ↑(LinearMap.comp
          (↑(LinearMap.comp
                (LinearMap.compr₂ (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X'))
                  (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom))
                (Finsupp.lsingle x))
            1)
          (Finsupp.lsingle x'))
      1 =
    ↑(LinearMap.comp
          (↑(LinearMap.comp
                (LinearMap.compr₂ (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X'))
                  ((μ R X X').hom ≫ (free R).map (f ⊗ g)))
                (Finsupp.lsingle x))
            1)
          (Finsupp.lsingle x'))
      1

tactic: intro ⟨y, y'⟩
state_before: case H.h.h.h.h.h
R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
x : X
x' : X'
⊢ ∀ (a : Y ⊗ Y'),
    ↑(↑(LinearMap.comp
                (↑(LinearMap.comp
                      (LinearMap.compr₂ (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X'))
                        (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom))
                      (Finsupp.lsingle x))
                  1)
                (Finsupp.lsingle x'))
            1)
        a =
      ↑(↑(LinearMap.comp
                (↑(LinearMap.comp
                      (LinearMap.compr₂ (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X'))
                        ((μ R X X').hom ≫ (free R).map (f ⊗ g)))
                      (Finsupp.lsingle x))
                  1)
                (Finsupp.lsingle x'))
            1)
        a

tactic: change (finsuppTensorFinsupp' R Y Y')
  (Finsupp.mapDomain f (Finsupp.single x 1) ⊗ₜ[R] Finsupp.mapDomain g (Finsupp.single x' 1)) _
  = (Finsupp.mapDomain (f ⊗ g) (finsuppTensorFinsupp' R X X'
  (Finsupp.single x 1 ⊗ₜ[R] Finsupp.single x' 1))) _
state_before: case H.h.h.h.h.h
R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
x : X
x' : X'
y : Y
y' : Y'
⊢ ↑(↑(LinearMap.comp
              (↑(LinearMap.comp
                    (LinearMap.compr₂ (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X'))
                      (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom))
                    (Finsupp.lsingle x))
                1)
              (Finsupp.lsingle x'))
          1)
      (y, y') =
    ↑(↑(LinearMap.comp
              (↑(LinearMap.comp
                    (LinearMap.compr₂ (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X'))
                      ((μ R X X').hom ≫ (free R).map (f ⊗ g)))
                    (Finsupp.lsingle x))
                1)
              (Finsupp.lsingle x'))
          1)
      (y, y')

tactic: simp_rw [Finsupp.mapDomain_single, finsuppTensorFinsupp'_single_tmul_single, mul_one,
  Finsupp.mapDomain_single, CategoryTheory.tensor_apply]
state_before: case H.h.h.h.h.h
R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
x : X
x' : X'
y : Y
y' : Y'
⊢ ↑(↑(finsuppTensorFinsupp' R Y Y')
          (Finsupp.mapDomain f (Finsupp.single x 1) ⊗ₜ[R] Finsupp.mapDomain g (Finsupp.single x' 1)))
      (y, y') =
    ↑(Finsupp.mapDomain (f ⊗ g) (↑(finsuppTensorFinsupp' R X X') (Finsupp.single x 1 ⊗ₜ[R] Finsupp.single x' 1)))
      (y, y')