Theorem: LocalizedModule.add_smul'
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: induction' x using Localization.induction_on with datax
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x y : Localization S
z : LocalizedModule S M
⊢ (x + y) • z = x • z + y • z

tactic: induction' y using Localization.induction_on with datay
state_before: case H
R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
y : Localization S
z : LocalizedModule S M
datax : R × { x // x ∈ S }
⊢ (Localization.mk datax.fst datax.snd + y) • z = Localization.mk datax.fst datax.snd • z + y • z

tactic: induction' z using LocalizedModule.induction_on with m t
state_before: case H.H
R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
z : LocalizedModule S M
datax datay : R × { x // x ∈ S }
⊢ (Localization.mk datax.fst datax.snd + Localization.mk datay.fst datay.snd) • z =
    Localization.mk datax.fst datax.snd • z + Localization.mk datay.fst datay.snd • z

tactic: rcases datax, datay with ⟨⟨r, s⟩, ⟨r', s'⟩⟩
state_before: case H.H.h
R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
datax datay : R × { x // x ∈ S }
m : M
t : { x // x ∈ S }
⊢ (Localization.mk datax.fst datax.snd + Localization.mk datay.fst datay.snd) • mk m t =
    Localization.mk datax.fst datax.snd • mk m t + Localization.mk datay.fst datay.snd • mk m t

tactic: rw [Localization.add_mk, mk_smul_mk, mk_smul_mk, mk_smul_mk, mk_add_mk, mk_eq]
state_before: case H.H.h.mk.mk
R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
m : M
t : { x // x ∈ S }
r : R
s : { x // x ∈ S }
r' : R
s' : { x // x ∈ S }
⊢ (Localization.mk (r, s).fst (r, s).snd + Localization.mk (r', s').fst (r', s').snd) • mk m t =
    Localization.mk (r, s).fst (r, s).snd • mk m t + Localization.mk (r', s').fst (r', s').snd • mk m t

tactic: use 1
state_before: case H.H.h.mk.mk
R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
m : M
t : { x // x ∈ S }
r : R
s : { x // x ∈ S }
r' : R
s' : { x // x ∈ S }
⊢ ∃ u,
    u • ((r, s).snd * t * ((r', s').snd * t)) • (↑(r, s).snd * (r', s').fst + ↑(r', s').snd * (r, s).fst) • m =
      u • ((r, s).snd * (r', s').snd * t) • (((r', s').snd * t) • (r, s).fst • m + ((r, s).snd * t) • (r', s').fst • m)

tactic: simp only [one_smul, add_smul, smul_add, ← mul_smul, Submonoid.smul_def, Submonoid.coe_mul,
  Submonoid.coe_one]
state_before: case H.H.h.mk.mk
R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
m : M
t : { x // x ∈ S }
r : R
s : { x // x ∈ S }
r' : R
s' : { x // x ∈ S }
⊢ 1 • ((r, s).snd * t * ((r', s').snd * t)) • (↑(r, s).snd * (r', s').fst + ↑(r', s').snd * (r, s).fst) • m =
    1 • ((r, s).snd * (r', s').snd * t) • (((r', s').snd * t) • (r, s).fst • m + ((r, s).snd * t) • (r', s').fst • m)

tactic: rw [add_comm]
state_before: case H.H.h.mk.mk
R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
m : M
t : { x // x ∈ S }
r : R
s : { x // x ∈ S }
r' : R
s' : { x // x ∈ S }
⊢ (↑s * ↑t * (↑s' * ↑t) * (↑s * r')) • m + (↑s * ↑t * (↑s' * ↑t) * (↑s' * r)) • m =
    (↑s * ↑s' * ↑t * (↑s' * ↑t * r)) • m + (↑s * ↑s' * ↑t * (↑s * ↑t * r')) • m

tactic: ring_nf
state_before: case H.H.h.mk.mk
R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
m : M
t : { x // x ∈ S }
r : R
s : { x // x ∈ S }
r' : R
s' : { x // x ∈ S }
⊢ (↑s * ↑t * (↑s' * ↑t) * (↑s' * r)) • m + (↑s * ↑t * (↑s' * ↑t) * (↑s * r')) • m =
    (↑s * ↑s' * ↑t * (↑s' * ↑t * r)) • m + (↑s * ↑s' * ↑t * (↑s * ↑t * r')) • m