l3lab/ntp-mathlib huggingface dataset:
theorem stdBasis_eq_stdBasisMatrix (i : n) (j : m) [DecidableEq n] [DecidableEq m] :
    stdBasis R n m (i, j) = stdBasisMatrix i j (1 : R) := by
  -- Porting note: `simp` fails to apply `Pi.basis_apply`
  ext a b
  by_cases hi : i = a <;> 

Proof state:
case pos
R : Type u_1
m : Type u_2
n : Type u_3
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Semiring R
i : n
j : m
inst✝¹ : DecidableEq n
inst✝ : DecidableEq m
a : n
b : m
hi : i = a
⊢ (stdBasis R n m) (i, j) a b = stdBasisMatrix i j 1 a b

Next tactic:
by_cases hj : j = b
theorem stdBasis_eq_stdBasisMatrix (i : n) (j : m) [DecidableEq n] [DecidableEq m] :
    stdBasis R n m (i, j) = stdBasisMatrix i j (1 : R) := by
  -- Porting note: `simp` fails to apply `Pi.basis_apply`
  ext a b
  by_cases hi : i = a <;> 

Proof state:
case neg
R : Type u_1
m : Type u_2
n : Type u_3
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Semiring R
i : n
j : m
inst✝¹ : DecidableEq n
inst✝ : DecidableEq m
a : n
b : m
hi : ¬i = a
⊢ (stdBasis R n m) (i, j) a b = stdBasisMatrix i j 1 a b

Next tactic:
by_cases hj : j = b
theorem stdBasis_eq_stdBasisMatrix (i : n) (j : m) [DecidableEq n] [DecidableEq m] :
    stdBasis R n m (i, j) = stdBasisMatrix i j (1 : R) := by
  -- Porting note: `simp` fails to apply `Pi.basis_apply`
  ext a b
  by_cases hi : i = a <;> by_cases hj : j = b
  · 

Proof state:
case pos
R : Type u_1
m : Type u_2
n : Type u_3
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Semiring R
i : n
j : m
inst✝¹ : DecidableEq n
inst✝ : DecidableEq m
a : n
b : m
hi : i = a
hj : j = b
⊢ (stdBasis R n m) (i, j) a b = stdBasisMatrix i j 1 a b

Next tactic:
simp [stdBasis, hi, hj, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      StdBasisMatrix.apply_same]
theorem stdBasis_eq_stdBasisMatrix (i : n) (j : m) [DecidableEq n] [DecidableEq m] :
    stdBasis R n m (i, j) = stdBasisMatrix i j (1 : R) := by
  -- Porting note: `simp` fails to apply `Pi.basis_apply`
  ext a b
  by_cases hi : i = a <;> by_cases hj : j = b
  · simp [stdBasis, hi, hj, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      StdBasisMatrix.apply_same]
    

Proof state:
case pos
R : Type u_1
m : Type u_2
n : Type u_3
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Semiring R
i : n
j : m
inst✝¹ : DecidableEq n
inst✝ : DecidableEq m
a : n
b : m
hi : i = a
hj : j = b
⊢ (Pi.basis fun x => Pi.basisFun R m) { fst := a, snd := b } a b = 1

Next tactic:
erw [Pi.basis_apply]
theorem stdBasis_eq_stdBasisMatrix (i : n) (j : m) [DecidableEq n] [DecidableEq m] :
    stdBasis R n m (i, j) = stdBasisMatrix i j (1 : R) := by
  -- Porting note: `simp` fails to apply `Pi.basis_apply`
  ext a b
  by_cases hi : i = a <;> by_cases hj : j = b
  · simp [stdBasis, hi, hj, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      StdBasisMatrix.apply_same]
    erw [Pi.basis_apply]
    

Proof state:
case pos
R : Type u_1
m : Type u_2
n : Type u_3
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Semiring R
i : n
j : m
inst✝¹ : DecidableEq n
inst✝ : DecidableEq m
a : n
b : m
hi : i = a
hj : j = b
⊢ (LinearMap.stdBasis R (fun a => m → R) { fst := a, snd := b }.fst) ((Pi.basisFun R m) { fst := a, snd := b }.snd) a
      b =
    1

Next tactic:
simp
theorem stdBasis_eq_stdBasisMatrix (i : n) (j : m) [DecidableEq n] [DecidableEq m] :
    stdBasis R n m (i, j) = stdBasisMatrix i j (1 : R) := by
  -- Porting note: `simp` fails to apply `Pi.basis_apply`
  ext a b
  by_cases hi : i = a <;> by_cases hj : j = b
  · simp [stdBasis, hi, hj, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      StdBasisMatrix.apply_same]
    erw [Pi.basis_apply]
    simp
  · 

Proof state:
case neg
R : Type u_1
m : Type u_2
n : Type u_3
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Semiring R
i : n
j : m
inst✝¹ : DecidableEq n
inst✝ : DecidableEq m
a : n
b : m
hi : i = a
hj : ¬j = b
⊢ (stdBasis R n m) (i, j) a b = stdBasisMatrix i j 1 a b

Next tactic:
simp only [stdBasis, hi, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      hj, and_false, not_false_iff, StdBasisMatrix.apply_of_ne]
theorem stdBasis_eq_stdBasisMatrix (i : n) (j : m) [DecidableEq n] [DecidableEq m] :
    stdBasis R n m (i, j) = stdBasisMatrix i j (1 : R) := by
  -- Porting note: `simp` fails to apply `Pi.basis_apply`
  ext a b
  by_cases hi : i = a <;> by_cases hj : j = b
  · simp [stdBasis, hi, hj, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      StdBasisMatrix.apply_same]
    erw [Pi.basis_apply]
    simp
  · simp only [stdBasis, hi, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      hj, and_false, not_false_iff, StdBasisMatrix.apply_of_ne]
    

Proof state:
case neg
R : Type u_1
m : Type u_2
n : Type u_3
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Semiring R
i : n
j : m
inst✝¹ : DecidableEq n
inst✝ : DecidableEq m
a : n
b : m
hi : i = a
hj : ¬j = b
⊢ (Pi.basis fun x => Pi.basisFun R m) { fst := a, snd := j } a b = 0

Next tactic:
erw [Pi.basis_apply]
theorem stdBasis_eq_stdBasisMatrix (i : n) (j : m) [DecidableEq n] [DecidableEq m] :
    stdBasis R n m (i, j) = stdBasisMatrix i j (1 : R) := by
  -- Porting note: `simp` fails to apply `Pi.basis_apply`
  ext a b
  by_cases hi : i = a <;> by_cases hj : j = b
  · simp [stdBasis, hi, hj, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      StdBasisMatrix.apply_same]
    erw [Pi.basis_apply]
    simp
  · simp only [stdBasis, hi, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      hj, and_false, not_false_iff, StdBasisMatrix.apply_of_ne]
    erw [Pi.basis_apply]
    

Proof state:
case neg
R : Type u_1
m : Type u_2
n : Type u_3
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Semiring R
i : n
j : m
inst✝¹ : DecidableEq n
inst✝ : DecidableEq m
a : n
b : m
hi : i = a
hj : ¬j = b
⊢ (LinearMap.stdBasis R (fun a => m → R) { fst := a, snd := j }.fst) ((Pi.basisFun R m) { fst := a, snd := j }.snd) a
      b =
    0

Next tactic:
simp [hj]
theorem stdBasis_eq_stdBasisMatrix (i : n) (j : m) [DecidableEq n] [DecidableEq m] :
    stdBasis R n m (i, j) = stdBasisMatrix i j (1 : R) := by
  -- Porting note: `simp` fails to apply `Pi.basis_apply`
  ext a b
  by_cases hi : i = a <;> by_cases hj : j = b
  · simp [stdBasis, hi, hj, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      StdBasisMatrix.apply_same]
    erw [Pi.basis_apply]
    simp
  · simp only [stdBasis, hi, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      hj, and_false, not_false_iff, StdBasisMatrix.apply_of_ne]
    erw [Pi.basis_apply]
    simp [hj]
  · 

Proof state:
case pos
R : Type u_1
m : Type u_2
n : Type u_3
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Semiring R
i : n
j : m
inst✝¹ : DecidableEq n
inst✝ : DecidableEq m
a : n
b : m
hi : ¬i = a
hj : j = b
⊢ (stdBasis R n m) (i, j) a b = stdBasisMatrix i j 1 a b

Next tactic:
simp only [stdBasis, hj, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      hi, and_true, not_false_iff, StdBasisMatrix.apply_of_ne]
theorem stdBasis_eq_stdBasisMatrix (i : n) (j : m) [DecidableEq n] [DecidableEq m] :
    stdBasis R n m (i, j) = stdBasisMatrix i j (1 : R) := by
  -- Porting note: `simp` fails to apply `Pi.basis_apply`
  ext a b
  by_cases hi : i = a <;> by_cases hj : j = b
  · simp [stdBasis, hi, hj, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      StdBasisMatrix.apply_same]
    erw [Pi.basis_apply]
    simp
  · simp only [stdBasis, hi, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      hj, and_false, not_false_iff, StdBasisMatrix.apply_of_ne]
    erw [Pi.basis_apply]
    simp [hj]
  · simp only [stdBasis, hj, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      hi, and_true, not_false_iff, StdBasisMatrix.apply_of_ne]
    

Proof state:
case pos
R : Type u_1
m : Type u_2
n : Type u_3
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Semiring R
i : n
j : m
inst✝¹ : DecidableEq n
inst✝ : DecidableEq m
a : n
b : m
hi : ¬i = a
hj : j = b
⊢ (Pi.basis fun x => Pi.basisFun R m) { fst := i, snd := b } a b = 0

Next tactic:
erw [Pi.basis_apply]
theorem stdBasis_eq_stdBasisMatrix (i : n) (j : m) [DecidableEq n] [DecidableEq m] :
    stdBasis R n m (i, j) = stdBasisMatrix i j (1 : R) := by
  -- Porting note: `simp` fails to apply `Pi.basis_apply`
  ext a b
  by_cases hi : i = a <;> by_cases hj : j = b
  · simp [stdBasis, hi, hj, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      StdBasisMatrix.apply_same]
    erw [Pi.basis_apply]
    simp
  · simp only [stdBasis, hi, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      hj, and_false, not_false_iff, StdBasisMatrix.apply_of_ne]
    erw [Pi.basis_apply]
    simp [hj]
  · simp only [stdBasis, hj, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      hi, and_true, not_false_iff, StdBasisMatrix.apply_of_ne]
    erw [Pi.basis_apply]
    

Proof state:
case pos
R : Type u_1
m : Type u_2
n : Type u_3
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Semiring R
i : n
j : m
inst✝¹ : DecidableEq n
inst✝ : DecidableEq m
a : n
b : m
hi : ¬i = a
hj : j = b
⊢ (LinearMap.stdBasis R (fun a => m → R) { fst := i, snd := b }.fst) ((Pi.basisFun R m) { fst := i, snd := b }.snd) a
      b =
    0

Next tactic:
simp [hi, hj, Ne.symm hi, LinearMap.stdBasis_ne]
theorem stdBasis_eq_stdBasisMatrix (i : n) (j : m) [DecidableEq n] [DecidableEq m] :
    stdBasis R n m (i, j) = stdBasisMatrix i j (1 : R) := by
  -- Porting note: `simp` fails to apply `Pi.basis_apply`
  ext a b
  by_cases hi : i = a <;> by_cases hj : j = b
  · simp [stdBasis, hi, hj, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      StdBasisMatrix.apply_same]
    erw [Pi.basis_apply]
    simp
  · simp only [stdBasis, hi, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      hj, and_false, not_false_iff, StdBasisMatrix.apply_of_ne]
    erw [Pi.basis_apply]
    simp [hj]
  · simp only [stdBasis, hj, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      hi, and_true, not_false_iff, StdBasisMatrix.apply_of_ne]
    erw [Pi.basis_apply]
    simp [hi, hj, Ne.symm hi, LinearMap.stdBasis_ne]
  · 

Proof state:
case neg
R : Type u_1
m : Type u_2
n : Type u_3
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Semiring R
i : n
j : m
inst✝¹ : DecidableEq n
inst✝ : DecidableEq m
a : n
b : m
hi : ¬i = a
hj : ¬j = b
⊢ (stdBasis R n m) (i, j) a b = stdBasisMatrix i j 1 a b

Next tactic:
simp only [stdBasis, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      hi, hj, and_self, not_false_iff, StdBasisMatrix.apply_of_ne]
theorem stdBasis_eq_stdBasisMatrix (i : n) (j : m) [DecidableEq n] [DecidableEq m] :
    stdBasis R n m (i, j) = stdBasisMatrix i j (1 : R) := by
  -- Porting note: `simp` fails to apply `Pi.basis_apply`
  ext a b
  by_cases hi : i = a <;> by_cases hj : j = b
  · simp [stdBasis, hi, hj, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      StdBasisMatrix.apply_same]
    erw [Pi.basis_apply]
    simp
  · simp only [stdBasis, hi, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      hj, and_false, not_false_iff, StdBasisMatrix.apply_of_ne]
    erw [Pi.basis_apply]
    simp [hj]
  · simp only [stdBasis, hj, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      hi, and_true, not_false_iff, StdBasisMatrix.apply_of_ne]
    erw [Pi.basis_apply]
    simp [hi, hj, Ne.symm hi, LinearMap.stdBasis_ne]
  · simp only [stdBasis, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      hi, hj, and_self, not_false_iff, StdBasisMatrix.apply_of_ne]
    

Proof state:
case neg
R : Type u_1
m : Type u_2
n : Type u_3
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Semiring R
i : n
j : m
inst✝¹ : DecidableEq n
inst✝ : DecidableEq m
a : n
b : m
hi : ¬i = a
hj : ¬j = b
⊢ (Pi.basis fun x => Pi.basisFun R m) { fst := i, snd := j } a b = 0

Next tactic:
erw [Pi.basis_apply]
theorem stdBasis_eq_stdBasisMatrix (i : n) (j : m) [DecidableEq n] [DecidableEq m] :
    stdBasis R n m (i, j) = stdBasisMatrix i j (1 : R) := by
  -- Porting note: `simp` fails to apply `Pi.basis_apply`
  ext a b
  by_cases hi : i = a <;> by_cases hj : j = b
  · simp [stdBasis, hi, hj, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      StdBasisMatrix.apply_same]
    erw [Pi.basis_apply]
    simp
  · simp only [stdBasis, hi, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      hj, and_false, not_false_iff, StdBasisMatrix.apply_of_ne]
    erw [Pi.basis_apply]
    simp [hj]
  · simp only [stdBasis, hj, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      hi, and_true, not_false_iff, StdBasisMatrix.apply_of_ne]
    erw [Pi.basis_apply]
    simp [hi, hj, Ne.symm hi, LinearMap.stdBasis_ne]
  · simp only [stdBasis, Basis.coe_reindex, comp_apply, Equiv.sigmaEquivProd_symm_apply,
      hi, hj, and_self, not_false_iff, StdBasisMatrix.apply_of_ne]
    erw [Pi.basis_apply]
    

Proof state:
case neg
R : Type u_1
m : Type u_2
n : Type u_3
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Semiring R
i : n
j : m
inst✝¹ : DecidableEq n
inst✝ : DecidableEq m
a : n
b : m
hi : ¬i = a
hj : ¬j = b
⊢ (LinearMap.stdBasis R (fun a => m → R) { fst := i, snd := j }.fst) ((Pi.basisFun R m) { fst := i, snd := j }.snd) a
      b =
    0

Next tactic:
simp [hi, hj, Ne.symm hj, Ne.symm hi, LinearMap.stdBasis_ne]
@[simp]
theorem finsuppTensorFinsupp_single (R M N ι κ : Sort _) [CommRing R] [AddCommGroup M] [Module R M]
    [AddCommGroup N] [Module R N] (i : ι) (m : M) (k : κ) (n : N) :
    finsuppTensorFinsupp R M N ι κ (Finsupp.single i m ⊗ₜ Finsupp.single k n) =
      Finsupp.single (i, k) (m ⊗ₜ n) :=
  by 

Proof state:
R✝ : Type u
M✝ : Type v
N✝ : Type w
inst✝⁹ : Ring R✝
inst✝⁸ : AddCommGroup M✝
inst✝⁷ : Module R✝ M✝
inst✝⁶ : AddCommGroup N✝
inst✝⁵ : Module R✝ N✝
R : Type u_1
M : Type u_2
N : Type u_3
ι : Type u_4
κ : Type u_5
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
i : ι
m : M
k : κ
n : N
⊢ (finsuppTensorFinsupp R M N ι κ) ((fun₀ | i => m) ⊗ₜ[R] fun₀ | k => n) = fun₀ | (i, k) => m ⊗ₜ[R] n

Next tactic:
classical simp [finsuppTensorFinsupp]
@[simp]
theorem finsuppTensorFinsupp_single (R M N ι κ : Sort _) [CommRing R] [AddCommGroup M] [Module R M]
    [AddCommGroup N] [Module R N] (i : ι) (m : M) (k : κ) (n : N) :
    finsuppTensorFinsupp R M N ι κ (Finsupp.single i m ⊗ₜ Finsupp.single k n) =
      Finsupp.single (i, k) (m ⊗ₜ n) :=
  by classical 

Proof state:
R✝ : Type u
M✝ : Type v
N✝ : Type w
inst✝⁹ : Ring R✝
inst✝⁸ : AddCommGroup M✝
inst✝⁷ : Module R✝ M✝
inst✝⁶ : AddCommGroup N✝
inst✝⁵ : Module R✝ N✝
R : Type u_1
M : Type u_2
N : Type u_3
ι : Type u_4
κ : Type u_5
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
i : ι
m : M
k : κ
n : N
⊢ (finsuppTensorFinsupp R M N ι κ) ((fun₀ | i => m) ⊗ₜ[R] fun₀ | k => n) = fun₀ | (i, k) => m ⊗ₜ[R] n

Next tactic:
simp [finsuppTensorFinsupp]
@[simp]
theorem finsuppTensorFinsupp_apply (R M N ι κ : Sort _) [CommRing R] [AddCommGroup M] [Module R M]
    [AddCommGroup N] [Module R N] (f : ι →₀ M) (g : κ →₀ N) (i : ι) (k : κ) :
    finsuppTensorFinsupp R M N ι κ (f ⊗ₜ g) (i, k) = f i ⊗ₜ g k := by
  

Proof state:
R✝ : Type u
M✝ : Type v
N✝ : Type w
inst✝⁹ : Ring R✝
inst✝⁸ : AddCommGroup M✝
inst✝⁷ : Module R✝ M✝
inst✝⁶ : AddCommGroup N✝
inst✝⁵ : Module R✝ N✝
R : Type u_1
M : Type u_2
N : Type u_3
ι : Type u_4
κ : Type u_5
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : ι →₀ M
g : κ →₀ N
i : ι
k : κ
⊢ ((finsuppTensorFinsupp R M N ι κ) (f ⊗ₜ[R] g)) (i, k) = f i ⊗ₜ[R] g k

Next tactic:
apply Finsupp.induction_linear f
@[simp]
theorem finsuppTensorFinsupp_apply (R M N ι κ : Sort _) [CommRing R] [AddCommGroup M] [Module R M]
    [AddCommGroup N] [Module R N] (f : ι →₀ M) (g : κ →₀ N) (i : ι) (k : κ) :
    finsuppTensorFinsupp R M N ι κ (f ⊗ₜ g) (i, k) = f i ⊗ₜ g k := by
  apply Finsupp.induction_linear f
  · 

Proof state:
case h0
R✝ : Type u
M✝ : Type v
N✝ : Type w
inst✝⁹ : Ring R✝
inst✝⁸ : AddCommGroup M✝
inst✝⁷ : Module R✝ M✝
inst✝⁶ : AddCommGroup N✝
inst✝⁵ : Module R✝ N✝
R : Type u_1
M : Type u_2
N : Type u_3
ι : Type u_4
κ : Type u_5
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : ι →₀ M
g : κ →₀ N
i : ι
k : κ
⊢ ((finsuppTensorFinsupp R M N ι κ) (0 ⊗ₜ[R] g)) (i, k) = 0 i ⊗ₜ[R] g k

Next tactic:
simp
@[simp]
theorem finsuppTensorFinsupp_apply (R M N ι κ : Sort _) [CommRing R] [AddCommGroup M] [Module R M]
    [AddCommGroup N] [Module R N] (f : ι →₀ M) (g : κ →₀ N) (i : ι) (k : κ) :
    finsuppTensorFinsupp R M N ι κ (f ⊗ₜ g) (i, k) = f i ⊗ₜ g k := by
  apply Finsupp.induction_linear f
  · simp
  · 

Proof state:
case hadd
R✝ : Type u
M✝ : Type v
N✝ : Type w
inst✝⁹ : Ring R✝
inst✝⁸ : AddCommGroup M✝
inst✝⁷ : Module R✝ M✝
inst✝⁶ : AddCommGroup N✝
inst✝⁵ : Module R✝ N✝
R : Type u_1
M : Type u_2
N : Type u_3
ι : Type u_4
κ : Type u_5
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : ι →₀ M
g : κ →₀ N
i : ι
k : κ
⊢ ∀ (f g_1 : ι →₀ M),
    ((finsuppTensorFinsupp R M N ι κ) (f ⊗ₜ[R] g)) (i, k) = f i ⊗ₜ[R] g k →
      ((finsuppTensorFinsupp R M N ι κ) (g_1 ⊗ₜ[R] g)) (i, k) = g_1 i ⊗ₜ[R] g k →
        ((finsuppTensorFinsupp R M N ι κ) ((f + g_1) ⊗ₜ[R] g)) (i, k) = (f + g_1) i ⊗ₜ[R] g k

Next tactic:
intro f₁ f₂ hf₁ hf₂
@[simp]
theorem finsuppTensorFinsupp_apply (R M N ι κ : Sort _) [CommRing R] [AddCommGroup M] [Module R M]
    [AddCommGroup N] [Module R N] (f : ι →₀ M) (g : κ →₀ N) (i : ι) (k : κ) :
    finsuppTensorFinsupp R M N ι κ (f ⊗ₜ g) (i, k) = f i ⊗ₜ g k := by
  apply Finsupp.induction_linear f
  · simp
  · intro f₁ f₂ hf₁ hf₂
    

Proof state:
case hadd
R✝ : Type u
M✝ : Type v
N✝ : Type w
inst✝⁹ : Ring R✝
inst✝⁸ : AddCommGroup M✝
inst✝⁷ : Module R✝ M✝
inst✝⁶ : AddCommGroup N✝
inst✝⁵ : Module R✝ N✝
R : Type u_1
M : Type u_2
N : Type u_3
ι : Type u_4
κ : Type u_5
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : ι →₀ M
g : κ →₀ N
i : ι
k : κ
f₁ f₂ : ι →₀ M
hf₁ : ((finsuppTensorFinsupp R M N ι κ) (f₁ ⊗ₜ[R] g)) (i, k) = f₁ i ⊗ₜ[R] g k
hf₂ : ((finsuppTensorFinsupp R M N ι κ) (f₂ ⊗ₜ[R] g)) (i, k) = f₂ i ⊗ₜ[R] g k
⊢ ((finsuppTensorFinsupp R M N ι κ) ((f₁ + f₂) ⊗ₜ[R] g)) (i, k) = (f₁ + f₂) i ⊗ₜ[R] g k

Next tactic:
simp [add_tmul, hf₁, hf₂]
@[simp]
theorem finsuppTensorFinsupp_apply (R M N ι κ : Sort _) [CommRing R] [AddCommGroup M] [Module R M]
    [AddCommGroup N] [Module R N] (f : ι →₀ M) (g : κ →₀ N) (i : ι) (k : κ) :
    finsuppTensorFinsupp R M N ι κ (f ⊗ₜ g) (i, k) = f i ⊗ₜ g k := by
  apply Finsupp.induction_linear f
  · simp
  · intro f₁ f₂ hf₁ hf₂
    simp [add_tmul, hf₁, hf₂]
  · 

Proof state:
case hsingle
R✝ : Type u
M✝ : Type v
N✝ : Type w
inst✝⁹ : Ring R✝
inst✝⁸ : AddCommGroup M✝
inst✝⁷ : Module R✝ M✝
inst✝⁶ : AddCommGroup N✝
inst✝⁵ : Module R✝ N✝
R : Type u_1
M : Type u_2
N : Type u_3
ι : Type u_4
κ : Type u_5
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : ι →₀ M
g : κ →₀ N
i : ι
k : κ
⊢ ∀ (a : ι) (b : M), ((finsuppTensorFinsupp R M N ι κ) ((fun₀ | a => b) ⊗ₜ[R] g)) (i, k) = (fun₀ | a => b) i ⊗ₜ[R] g k

Next tactic:
intro i' m
@[simp]
theorem finsuppTensorFinsupp_apply (R M N ι κ : Sort _) [CommRing R] [AddCommGroup M] [Module R M]
    [AddCommGroup N] [Module R N] (f : ι →₀ M) (g : κ →₀ N) (i : ι) (k : κ) :
    finsuppTensorFinsupp R M N ι κ (f ⊗ₜ g) (i, k) = f i ⊗ₜ g k := by
  apply Finsupp.induction_linear f
  · simp
  · intro f₁ f₂ hf₁ hf₂
    simp [add_tmul, hf₁, hf₂]
  · intro i' m
    

Proof state:
case hsingle
R✝ : Type u
M✝ : Type v
N✝ : Type w
inst✝⁹ : Ring R✝
inst✝⁸ : AddCommGroup M✝
inst✝⁷ : Module R✝ M✝
inst✝⁶ : AddCommGroup N✝
inst✝⁵ : Module R✝ N✝
R : Type u_1
M : Type u_2
N : Type u_3
ι : Type u_4
κ : Type u_5
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : ι →₀ M
g : κ →₀ N
i : ι
k : κ
i' : ι
m : M
⊢ ((finsuppTensorFinsupp R M N ι κ) ((fun₀ | i' => m) ⊗ₜ[R] g)) (i, k) = (fun₀ | i' => m) i ⊗ₜ[R] g k

Next tactic:
apply Finsupp.induction_linear g
@[simp]
theorem finsuppTensorFinsupp_apply (R M N ι κ : Sort _) [CommRing R] [AddCommGroup M] [Module R M]
    [AddCommGroup N] [Module R N] (f : ι →₀ M) (g : κ →₀ N) (i : ι) (k : κ) :
    finsuppTensorFinsupp R M N ι κ (f ⊗ₜ g) (i, k) = f i ⊗ₜ g k := by
  apply Finsupp.induction_linear f
  · simp
  · intro f₁ f₂ hf₁ hf₂
    simp [add_tmul, hf₁, hf₂]
  · intro i' m
    apply Finsupp.induction_linear g
    · 

Proof state:
case hsingle.h0
R✝ : Type u
M✝ : Type v
N✝ : Type w
inst✝⁹ : Ring R✝
inst✝⁸ : AddCommGroup M✝
inst✝⁷ : Module R✝ M✝
inst✝⁶ : AddCommGroup N✝
inst✝⁵ : Module R✝ N✝
R : Type u_1
M : Type u_2
N : Type u_3
ι : Type u_4
κ : Type u_5
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : ι →₀ M
g : κ →₀ N
i : ι
k : κ
i' : ι
m : M
⊢ ((finsuppTensorFinsupp R M N ι κ) ((fun₀ | i' => m) ⊗ₜ[R] 0)) (i, k) = (fun₀ | i' => m) i ⊗ₜ[R] 0 k

Next tactic:
simp
@[simp]
theorem finsuppTensorFinsupp_apply (R M N ι κ : Sort _) [CommRing R] [AddCommGroup M] [Module R M]
    [AddCommGroup N] [Module R N] (f : ι →₀ M) (g : κ →₀ N) (i : ι) (k : κ) :
    finsuppTensorFinsupp R M N ι κ (f ⊗ₜ g) (i, k) = f i ⊗ₜ g k := by
  apply Finsupp.induction_linear f
  · simp
  · intro f₁ f₂ hf₁ hf₂
    simp [add_tmul, hf₁, hf₂]
  · intro i' m
    apply Finsupp.induction_linear g
    · simp
    · 

Proof state:
case hsingle.hadd
R✝ : Type u
M✝ : Type v
N✝ : Type w
inst✝⁹ : Ring R✝
inst✝⁸ : AddCommGroup M✝
inst✝⁷ : Module R✝ M✝
inst✝⁶ : AddCommGroup N✝
inst✝⁵ : Module R✝ N✝
R : Type u_1
M : Type u_2
N : Type u_3
ι : Type u_4
κ : Type u_5
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : ι →₀ M
g : κ →₀ N
i : ι
k : κ
i' : ι
m : M
⊢ ∀ (f g : κ →₀ N),
    ((finsuppTensorFinsupp R M N ι κ) ((fun₀ | i' => m) ⊗ₜ[R] f)) (i, k) = (fun₀ | i' => m) i ⊗ₜ[R] f k →
      ((finsuppTensorFinsupp R M N ι κ) ((fun₀ | i' => m) ⊗ₜ[R] g)) (i, k) = (fun₀ | i' => m) i ⊗ₜ[R] g k →
        ((finsuppTensorFinsupp R M N ι κ) ((fun₀ | i' => m) ⊗ₜ[R] (f + g))) (i, k) = (fun₀ | i' => m) i ⊗ₜ[R] (f + g) k

Next tactic:
intro g₁ g₂ hg₁ hg₂
@[simp]
theorem finsuppTensorFinsupp_apply (R M N ι κ : Sort _) [CommRing R] [AddCommGroup M] [Module R M]
    [AddCommGroup N] [Module R N] (f : ι →₀ M) (g : κ →₀ N) (i : ι) (k : κ) :
    finsuppTensorFinsupp R M N ι κ (f ⊗ₜ g) (i, k) = f i ⊗ₜ g k := by
  apply Finsupp.induction_linear f
  · simp
  · intro f₁ f₂ hf₁ hf₂
    simp [add_tmul, hf₁, hf₂]
  · intro i' m
    apply Finsupp.induction_linear g
    · simp
    · intro g₁ g₂ hg₁ hg₂
      

Proof state:
case hsingle.hadd
R✝ : Type u
M✝ : Type v
N✝ : Type w
inst✝⁹ : Ring R✝
inst✝⁸ : AddCommGroup M✝
inst✝⁷ : Module R✝ M✝
inst✝⁶ : AddCommGroup N✝
inst✝⁵ : Module R✝ N✝
R : Type u_1
M : Type u_2
N : Type u_3
ι : Type u_4
κ : Type u_5
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : ι →₀ M
g : κ →₀ N
i : ι
k : κ
i' : ι
m : M
g₁ g₂ : κ →₀ N
hg₁ : ((finsuppTensorFinsupp R M N ι κ) ((fun₀ | i' => m) ⊗ₜ[R] g₁)) (i, k) = (fun₀ | i' => m) i ⊗ₜ[R] g₁ k
hg₂ : ((finsuppTensorFinsupp R M N ι κ) ((fun₀ | i' => m) ⊗ₜ[R] g₂)) (i, k) = (fun₀ | i' => m) i ⊗ₜ[R] g₂ k
⊢ ((finsuppTensorFinsupp R M N ι κ) ((fun₀ | i' => m) ⊗ₜ[R] (g₁ + g₂))) (i, k) = (fun₀ | i' => m) i ⊗ₜ[R] (g₁ + g₂) k

Next tactic:
simp [tmul_add, hg₁, hg₂]