File: Mathlib/RingTheory/TensorProduct/MvPolynomial.lean

full_name: MvPolynomial.rTensor
code: /-- The tensor product of a polynomial ring by a module is
  linearly equivalent to a Finsupp of a tensor product -/
noncomputable def rTensor :
    MvPolynomial σ S ⊗[R] N ≃ₗ[S] (σ →₀ ℕ) →₀ (S ⊗[R] N) 
goal: TensorProduct R (MvPolynomial σ S) N ≃ₗ[S] (σ →₀ ℕ) →₀ TensorProduct R S N

full_name: MvPolynomial.rTensor_apply_tmul
code: lemma rTensor_apply_tmul (p : MvPolynomial σ S) (n : N) :
    rTensor (p ⊗ₜ[R] n) = p.sum (fun i m ↦ Finsupp.single i (m ⊗ₜ[R] n)) 
goal: MvPolynomial.rTensor (p ⊗ₜ[R] n) = Finsupp.sum p fun i m => Finsupp.single i (m ⊗ₜ[R] n)

full_name: MvPolynomial.rTensor_apply_tmul_apply
code: lemma rTensor_apply_tmul_apply (p : MvPolynomial σ S) (n : N) (d : σ →₀ ℕ) :
    rTensor (p ⊗ₜ[R] n) d = (coeff d p) ⊗ₜ[R] n 
goal: (MvPolynomial.rTensor (p ⊗ₜ[R] n)) d = MvPolynomial.coeff d p ⊗ₜ[R] n

full_name: MvPolynomial.rTensor_apply_monomial_tmul
code: lemma rTensor_apply_monomial_tmul (e : σ →₀ ℕ) (s : S) (n : N) (d : σ →₀ ℕ) :
    rTensor (monomial e s ⊗ₜ[R] n) d = if e = d then s ⊗ₜ[R] n else 0 
goal: (MvPolynomial.rTensor ((MvPolynomial.monomial e) s ⊗ₜ[R] n)) d = if e = d then s ⊗ₜ[R] n else 0

full_name: MvPolynomial.rTensor_apply_X_tmul
code: lemma rTensor_apply_X_tmul (s : σ) (n : N) (d : σ →₀ ℕ) :
    rTensor (X s ⊗ₜ[R] n) d = if Finsupp.single s 1 = d then (1 : S) ⊗ₜ[R] n else 0 
goal: (MvPolynomial.rTensor (MvPolynomial.X s ⊗ₜ[R] n)) d = if Finsupp.single s 1 = d then 1 ⊗ₜ[R] n else 0

full_name: MvPolynomial.rTensor_apply
code: lemma rTensor_apply (t : MvPolynomial σ S ⊗[R] N) (d : σ →₀ ℕ) :
    rTensor t d = ((lcoeff S d).restrictScalars R).rTensor N t 
goal: (MvPolynomial.rTensor t) d = (LinearMap.rTensor N (↑R (MvPolynomial.lcoeff S d))) t

full_name: MvPolynomial.rTensor_symm_apply_single
code: @[simp]
lemma rTensor_symm_apply_single (d : σ →₀ ℕ) (s : S) (n : N) :
    rTensor.symm (Finsupp.single d (s ⊗ₜ n)) =
      (monomial d s) ⊗ₜ[R] n 
goal: MvPolynomial.rTensor.symm (Finsupp.single d (s ⊗ₜ[R] n)) = (MvPolynomial.monomial d) s ⊗ₜ[R] n

full_name: MvPolynomial.scalarRTensor
code: /-- The tensor product of the polynomial algebra by a module
  is linearly equivalent to a Finsupp of that module -/
noncomputable def scalarRTensor :
    MvPolynomial σ R ⊗[R] N ≃ₗ[R] (σ →₀ ℕ) →₀ N 
goal: TensorProduct R (MvPolynomial σ R) N ≃ₗ[R] (σ →₀ ℕ) →₀ N

full_name: MvPolynomial.scalarRTensor_apply_tmul
code: lemma scalarRTensor_apply_tmul (p : MvPolynomial σ R) (n : N) :
    scalarRTensor (p ⊗ₜ[R] n) = p.sum (fun i m ↦ Finsupp.single i (m • n)) 
goal: MvPolynomial.scalarRTensor (p ⊗ₜ[R] n) = Finsupp.sum p fun i m => Finsupp.single i (m • n)

full_name: MvPolynomial.scalarRTensor_apply_tmul_apply
code: lemma scalarRTensor_apply_tmul_apply (p : MvPolynomial σ R) (n : N) (d : σ →₀ ℕ) :
    scalarRTensor (p ⊗ₜ[R] n) d = coeff d p • n 
goal: (MvPolynomial.scalarRTensor (p ⊗ₜ[R] n)) d = MvPolynomial.coeff d p • n

full_name: MvPolynomial.scalarRTensor_apply_monomial_tmul
code: lemma scalarRTensor_apply_monomial_tmul (e : σ →₀ ℕ) (r : R) (n : N) (d : σ →₀ ℕ) :
    scalarRTensor (monomial e r ⊗ₜ[R] n) d = if e = d then r • n else 0 
goal: (MvPolynomial.scalarRTensor ((MvPolynomial.monomial e) r ⊗ₜ[R] n)) d = if e = d then r • n else 0

full_name: MvPolynomial.scalarRTensor_apply_X_tmul_apply
code: lemma scalarRTensor_apply_X_tmul_apply (s : σ) (n : N) (d : σ →₀ ℕ) :
    scalarRTensor (X s ⊗ₜ[R] n) d = if Finsupp.single s 1 = d then n else 0 
goal: (MvPolynomial.scalarRTensor (MvPolynomial.X s ⊗ₜ[R] n)) d = if Finsupp.single s 1 = d then n else 0

full_name: MvPolynomial.scalarRTensor_symm_apply_single
code: lemma scalarRTensor_symm_apply_single (d : σ →₀ ℕ) (n : N) :
    scalarRTensor.symm (Finsupp.single d n) = (monomial d 1) ⊗ₜ[R] n 
goal: MvPolynomial.scalarRTensor.symm (Finsupp.single d n) = (MvPolynomial.monomial d) 1 ⊗ₜ[R] n

full_name: MvPolynomial.rTensorAlgHom
code: /-- The algebra morphism from a tensor product of a polynomial algebra
  by an algebra to a polynomial algebra -/
noncomputable def rTensorAlgHom :
    (MvPolynomial σ S) ⊗[R] N →ₐ[S] MvPolynomial σ (S ⊗[R] N) 
goal: TensorProduct R (MvPolynomial σ S) N →ₐ[S] MvPolynomial σ (TensorProduct R S N)

full_name: MvPolynomial.coeff_rTensorAlgHom_tmul
code: @[simp]
lemma coeff_rTensorAlgHom_tmul
    (p : MvPolynomial σ S) (n : N) (d : σ →₀ ℕ) :
    coeff d (rTensorAlgHom (p ⊗ₜ[R] n)) = (coeff d p) ⊗ₜ[R] n 
goal: MvPolynomial.coeff d (MvPolynomial.rTensorAlgHom (p ⊗ₜ[R] n)) = MvPolynomial.coeff d p ⊗ₜ[R] n

full_name: MvPolynomial.coeff_rTensorAlgHom_monomial_tmul
code: lemma coeff_rTensorAlgHom_monomial_tmul
    (e : σ →₀ ℕ) (s : S) (n : N) (d : σ →₀ ℕ) :
    coeff d (rTensorAlgHom (monomial e s ⊗ₜ[R] n)) =
      if e = d then s ⊗ₜ[R] n else 0 
goal: MvPolynomial.coeff d (MvPolynomial.rTensorAlgHom ((MvPolynomial.monomial e) s ⊗ₜ[R] n)) = if e = d then s ⊗ₜ[R] n else 0

full_name: MvPolynomial.rTensorAlgHom_toLinearMap
code: lemma rTensorAlgHom_toLinearMap :
    (rTensorAlgHom :
      MvPolynomial σ S ⊗[R] N →ₐ[S] MvPolynomial σ (S ⊗[R] N)).toLinearMap =
      rTensor.toLinearMap 
goal: MvPolynomial.rTensorAlgHom.toLinearMap = ↑MvPolynomial.rTensor

full_name: MvPolynomial.rTensorAlgHom_apply_eq
code: lemma rTensorAlgHom_apply_eq (p : MvPolynomial σ S ⊗[R] N) :
    rTensorAlgHom (S := S) p = rTensor p 
goal: MvPolynomial.rTensorAlgHom p = MvPolynomial.rTensor p

full_name: MvPolynomial.rTensorAlgEquiv
code: /-- The tensor product of a polynomial algebra by an algebra
  is algebraically equivalent to a polynomial algebra -/
noncomputable def rTensorAlgEquiv :
    (MvPolynomial σ S) ⊗[R] N ≃ₐ[S] MvPolynomial σ (S ⊗[R] N) 
goal: TensorProduct R (MvPolynomial σ S) N ≃ₐ[S] MvPolynomial σ (TensorProduct R S N)

full_name: MvPolynomial.scalarRTensorAlgEquiv
code: /-- The tensor product of the polynomial algebra by an algebra
  is algebraically equivalent to a polynomial algebra with
  coefficients in that algegra -/
noncomputable def scalarRTensorAlgEquiv :
    MvPolynomial σ R ⊗[R] N ≃ₐ[R] MvPolynomial σ N 
goal: TensorProduct R (MvPolynomial σ R) N ≃ₐ[R] MvPolynomial σ N

full_name: MvPolynomial.algebraTensorAlgEquiv
code: /-- Tensoring `MvPolynomial σ R` on the left by an `R`-algebra `A` is algebraically
equivalent to `M̀vPolynomial σ A`. -/
noncomputable def algebraTensorAlgEquiv :
    A ⊗[R] MvPolynomial σ R ≃ₐ[A] MvPolynomial σ A 
goal: TensorProduct R A (MvPolynomial σ R) ≃ₐ[A] MvPolynomial σ A

full_name: MvPolynomial.algebraTensorAlgEquiv_tmul
code: @[simp]
lemma algebraTensorAlgEquiv_tmul (a : A) (p : MvPolynomial σ R) :
    algebraTensorAlgEquiv R A (a ⊗ₜ p) = a • MvPolynomial.map (algebraMap R A) p 
goal: (MvPolynomial.algebraTensorAlgEquiv R A) (a ⊗ₜ[R] p) = a • (MvPolynomial.map (algebraMap R A)) p

full_name: MvPolynomial.algebraTensorAlgEquiv_symm_X
code: @[simp]
lemma algebraTensorAlgEquiv_symm_X (s : σ) :
    (algebraTensorAlgEquiv R A).symm (X s) = 1 ⊗ₜ X s 
goal: (MvPolynomial.algebraTensorAlgEquiv R A).symm (MvPolynomial.X s) = 1 ⊗ₜ[R] MvPolynomial.X s

full_name: MvPolynomial.algebraTensorAlgEquiv_symm_monomial
code: @[simp]
lemma algebraTensorAlgEquiv_symm_monomial (m : σ →₀ ℕ) (a : A) :
    (algebraTensorAlgEquiv R A).symm (monomial m a) = a ⊗ₜ monomial m 1 
goal: (MvPolynomial.algebraTensorAlgEquiv R A).symm ((MvPolynomial.monomial m) a) = a ⊗ₜ[R] (MvPolynomial.monomial m) 1