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

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)
state_after: case H
R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
⊢ (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
      (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) =
    (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ 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'
⊢ (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
      (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) =
    (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g))
state_after: case H.h
R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
⊢ ∀ (a : X),
    (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
          (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) ∘ₗ
        Finsupp.lsingle a =
      (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g)) ∘ₗ
        Finsupp.lsingle a

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),
    (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
          (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) ∘ₗ
        Finsupp.lsingle a =
      (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g)) ∘ₗ
        Finsupp.lsingle a
state_after: case H.h
R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
x : X
⊢ (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
        (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) ∘ₗ
      Finsupp.lsingle x =
    (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g)) ∘ₗ
      Finsupp.lsingle x

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
⊢ (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
        (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) ∘ₗ
      Finsupp.lsingle x =
    (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g)) ∘ₗ
      Finsupp.lsingle x
state_after: case H.h.h
R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
x : X
⊢ ((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
          (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) ∘ₗ
        Finsupp.lsingle x)
      1 =
    ((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g)) ∘ₗ
        Finsupp.lsingle x)
      1

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
⊢ ((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
          (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) ∘ₗ
        Finsupp.lsingle x)
      1 =
    ((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g)) ∘ₗ
        Finsupp.lsingle x)
      1
state_after: 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'),
    ((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
              (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) ∘ₗ
            Finsupp.lsingle x)
          1 ∘ₗ
        Finsupp.lsingle a =
      ((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g)) ∘ₗ
            Finsupp.lsingle x)
          1 ∘ₗ
        Finsupp.lsingle a

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'),
    ((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
              (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) ∘ₗ
            Finsupp.lsingle x)
          1 ∘ₗ
        Finsupp.lsingle a =
      ((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g)) ∘ₗ
            Finsupp.lsingle x)
          1 ∘ₗ
        Finsupp.lsingle a
state_after: 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'
⊢ ((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
            (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) ∘ₗ
          Finsupp.lsingle x)
        1 ∘ₗ
      Finsupp.lsingle x' =
    ((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g)) ∘ₗ
          Finsupp.lsingle x)
        1 ∘ₗ
      Finsupp.lsingle x'

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'
⊢ ((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
            (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) ∘ₗ
          Finsupp.lsingle x)
        1 ∘ₗ
      Finsupp.lsingle x' =
    ((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g)) ∘ₗ
          Finsupp.lsingle x)
        1 ∘ₗ
      Finsupp.lsingle x'
state_after: 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'
⊢ (((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
              (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) ∘ₗ
            Finsupp.lsingle x)
          1 ∘ₗ
        Finsupp.lsingle x')
      1 =
    (((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g)) ∘ₗ
            Finsupp.lsingle x)
          1 ∘ₗ
        Finsupp.lsingle x')
      1

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'
⊢ (((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
              (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) ∘ₗ
            Finsupp.lsingle x)
          1 ∘ₗ
        Finsupp.lsingle x')
      1 =
    (((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g)) ∘ₗ
            Finsupp.lsingle x)
          1 ∘ₗ
        Finsupp.lsingle x')
      1
state_after: 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'),
    ((((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
                  (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) ∘ₗ
                Finsupp.lsingle x)
              1 ∘ₗ
            Finsupp.lsingle x')
          1)
        a =
      ((((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g)) ∘ₗ
                Finsupp.lsingle x)
              1 ∘ₗ
            Finsupp.lsingle x')
          1)
        a

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'),
    ((((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
                  (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) ∘ₗ
                Finsupp.lsingle x)
              1 ∘ₗ
            Finsupp.lsingle x')
          1)
        a =
      ((((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g)) ∘ₗ
                Finsupp.lsingle x)
              1 ∘ₗ
            Finsupp.lsingle x')
          1)
        a
state_after: 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'
⊢ ((((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
                (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) ∘ₗ
              Finsupp.lsingle x)
            1 ∘ₗ
          Finsupp.lsingle x')
        1)
      (y, y') =
    ((((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g)) ∘ₗ
              Finsupp.lsingle x)
            1 ∘ₗ
          Finsupp.lsingle x')
        1)
      (y, y')

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'
⊢ ((((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
                (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) ∘ₗ
              Finsupp.lsingle x)
            1 ∘ₗ
          Finsupp.lsingle x')
        1)
      (y, y') =
    ((((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g)) ∘ₗ
              Finsupp.lsingle x)
            1 ∘ₗ
          Finsupp.lsingle x')
        1)
      (y, y')
state_after: 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')

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')
state_after: 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'
⊢ (Finsupp.single (f x, g x') 1) (y, y') = (Finsupp.single (f x, g x') 1) (y, y')

tactic: rfl
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'
⊢ (Finsupp.single (f x, g x') 1) (y, y') = (Finsupp.single (f x, g x') 1) (y, y')
state_after: no goals