-- Mathlib/Algebra/Polynomial/Module/Basic.lean
theorem map_smul (f : M →ₗ[R] M') (p : R[X]) (q : PolynomialModule R M) :
    map R' f (p • q) = p.map (algebraMap R R') • map R' f q

Proof state:
R : Type u_1
M : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
R' : Type u_4
M' : Type u_5
inst✝⁵ : CommRing R'
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R' M'
inst✝² : Module R M'
inst✝¹ : Algebra R R'
inst✝ : IsScalarTower R R' M'
f : M →ₗ[R] M'
p : R[X]
q : PolynomialModule R M
⊢ (map R' f) (p • q) = Polynomial.map (algebraMap R R') p • (map R' f) q

Tactic:
apply induction_linear q

Result:
case h0
R : Type u_1
M : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
R' : Type u_4
M' : Type u_5
inst✝⁵ : CommRing R'
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R' M'
inst✝² : Module R M'
inst✝¹ : Algebra R R'
inst✝ : IsScalarTower R R' M'
f : M →ₗ[R] M'
p : R[X]
q : PolynomialModule R M
⊢ (map R' f) (p • 0) = Polynomial.map (algebraMap R R') p • (map R' f) 0

case hadd
R : Type u_1
M : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
R' : Type u_4
M' : Type u_5
inst✝⁵ : CommRing R'
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R' M'
inst✝² : Module R M'
inst✝¹ : Algebra R R'
inst✝ : IsScalarTower R R' M'
f : M →ₗ[R] M'
p : R[X]
q : PolynomialModule R M
⊢ ∀ (f_1 g : PolynomialModule R M),
    (map R' f) (p • f_1) = Polynomial.map (algebraMap R R') p • (map R' f) f_1 →
      (map R' f) (p • g) = Polynomial.map (algebraMap R R') p • (map R' f) g →
        (map R' f) (p • (f_1 + g)) = Polynomial.map (algebraMap R R') p • (map R' f) (f_1 + g)

case hsingle
R : Type u_1
M : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
R' : Type u_4
M' : Type u_5
inst✝⁵ : CommRing R'
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R' M'
inst✝² : Module R M'
inst✝¹ : Algebra R R'
inst✝ : IsScalarTower R R' M'
f : M →ₗ[R] M'
p : R[X]
q : PolynomialModule R M
⊢ ∀ (a : ℕ) (b : M), (map R' f) (p • (single R a) b) = Polynomial.map (algebraMap R R') p • (map R' f) ((single R a) b)

Proof state:
case hadd
R : Type u_1
M : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
R' : Type u_4
M' : Type u_5
inst✝⁵ : CommRing R'
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R' M'
inst✝² : Module R M'
inst✝¹ : Algebra R R'
inst✝ : IsScalarTower R R' M'
f✝ : M →ₗ[R] M'
p : R[X]
q f g : PolynomialModule R M
e₁ : (map R' f✝) (p • f) = Polynomial.map (algebraMap R R') p • (map R' f✝) f
e₂ : (map R' f✝) (p • g) = Polynomial.map (algebraMap R R') p • (map R' f✝) g
⊢ (map R' f✝) (p • (f + g)) = Polynomial.map (algebraMap R R') p • (map R' f✝) (f + g)

Tactic:
rw [smul_add, map_add, e₁, e₂, map_add, smul_add]

Result:
no goals

Proof state:
case hsingle.h_add
R : Type u_1
M : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
R' : Type u_4
M' : Type u_5
inst✝⁵ : CommRing R'
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R' M'
inst✝² : Module R M'
inst✝¹ : Algebra R R'
inst✝ : IsScalarTower R R' M'
f : M →ₗ[R] M'
q : PolynomialModule R M
i : ℕ
m : M
p✝ q✝ : R[X]
e₁ : (map R' f) (p✝ • (single R i) m) = Polynomial.map (algebraMap R R') p✝ • (map R' f) ((single R i) m)
e₂ : (map R' f) (q✝ • (single R i) m) = Polynomial.map (algebraMap R R') q✝ • (map R' f) ((single R i) m)
⊢ (map R' f) ((p✝ + q✝) • (single R i) m) = Polynomial.map (algebraMap R R') (p✝ + q✝) • (map R' f) ((single R i) m)

Tactic:
rw [add_smul, map_add, e₁, e₂, Polynomial.map_add, add_smul]

Result:
no goals

Proof state:
case h0
R : Type u_1
M : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
R' : Type u_4
M' : Type u_5
inst✝⁵ : CommRing R'
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R' M'
inst✝² : Module R M'
inst✝¹ : Algebra R R'
inst✝ : IsScalarTower R R' M'
f : M →ₗ[R] M'
p : R[X]
q : PolynomialModule R M
⊢ (map R' f) (p • 0) = Polynomial.map (algebraMap R R') p • (map R' f) 0

Tactic:
rw [smul_zero, map_zero, smul_zero]

Result:
no goals

Proof state:
case hsingle.h_monomial
R : Type u_1
M : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
R' : Type u_4
M' : Type u_5
inst✝⁵ : CommRing R'
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R' M'
inst✝² : Module R M'
inst✝¹ : Algebra R R'
inst✝ : IsScalarTower R R' M'
f : M →ₗ[R] M'
q : PolynomialModule R M
i : ℕ
m : M
n✝ : ℕ
a✝ : R
⊢ (map R' f) ((monomial n✝) a✝ • (single R i) m) =
    Polynomial.map (algebraMap R R') ((monomial n✝) a✝) • (map R' f) ((single R i) m)

Tactic:
rw [monomial_smul_single, map_single, Polynomial.map_monomial, map_single,
monomial_smul_single, f.map_smul, algebraMap_smul]

Result:
no goals

Proof state:
case hsingle
R : Type u_1
M : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
R' : Type u_4
M' : Type u_5
inst✝⁵ : CommRing R'
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R' M'
inst✝² : Module R M'
inst✝¹ : Algebra R R'
inst✝ : IsScalarTower R R' M'
f : M →ₗ[R] M'
p : R[X]
q : PolynomialModule R M
i : ℕ
m : M
⊢ (map R' f) (p • (single R i) m) = Polynomial.map (algebraMap R R') p • (map R' f) ((single R i) m)

Tactic:
induction p using Polynomial.induction_on' with
| h_add _ _ e₁ e₂ => rw [add_smul, map_add, e₁, e₂, Polynomial.map_add, add_smul]
| h_monomial => rw [monomial_smul_single, map_single, Polynomial.map_monomial, map_single,
    monomial_smul_single, f.map_smul, algebraMap_smul]

Result:
no goals

Proof state:
case hadd
R : Type u_1
M : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
R' : Type u_4
M' : Type u_5
inst✝⁵ : CommRing R'
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R' M'
inst✝² : Module R M'
inst✝¹ : Algebra R R'
inst✝ : IsScalarTower R R' M'
f : M →ₗ[R] M'
p : R[X]
q : PolynomialModule R M
⊢ ∀ (f_1 g : PolynomialModule R M),
    (map R' f) (p • f_1) = Polynomial.map (algebraMap R R') p • (map R' f) f_1 →
      (map R' f) (p • g) = Polynomial.map (algebraMap R R') p • (map R' f) g →
        (map R' f) (p • (f_1 + g)) = Polynomial.map (algebraMap R R') p • (map R' f) (f_1 + g)

Tactic:
intro f g e₁ e₂

Result:
case hadd
R : Type u_1
M : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
R' : Type u_4
M' : Type u_5
inst✝⁵ : CommRing R'
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R' M'
inst✝² : Module R M'
inst✝¹ : Algebra R R'
inst✝ : IsScalarTower R R' M'
f✝ : M →ₗ[R] M'
p : R[X]
q f g : PolynomialModule R M
e₁ : (map R' f✝) (p • f) = Polynomial.map (algebraMap R R') p • (map R' f✝) f
e₂ : (map R' f✝) (p • g) = Polynomial.map (algebraMap R R') p • (map R' f✝) g
⊢ (map R' f✝) (p • (f + g)) = Polynomial.map (algebraMap R R') p • (map R' f✝) (f + g)

Proof state:
case hsingle
R : Type u_1
M : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
R' : Type u_4
M' : Type u_5
inst✝⁵ : CommRing R'
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R' M'
inst✝² : Module R M'
inst✝¹ : Algebra R R'
inst✝ : IsScalarTower R R' M'
f : M →ₗ[R] M'
p : R[X]
q : PolynomialModule R M
⊢ ∀ (a : ℕ) (b : M), (map R' f) (p • (single R a) b) = Polynomial.map (algebraMap R R') p • (map R' f) ((single R a) b)

Tactic:
intro i m

Result:
case hsingle
R : Type u_1
M : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
R' : Type u_4
M' : Type u_5
inst✝⁵ : CommRing R'
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R' M'
inst✝² : Module R M'
inst✝¹ : Algebra R R'
inst✝ : IsScalarTower R R' M'
f : M →ₗ[R] M'
p : R[X]
q : PolynomialModule R M
i : ℕ
m : M
⊢ (map R' f) (p • (single R i) m) = Polynomial.map (algebraMap R R') p • (map R' f) ((single R i) m)