Theorem: MvPowerSeries.X_pow_dvd_iff
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: constructor
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
⊢ X s ^ n ∣ φ ↔ ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0

tactic: rintro ⟨φ, rfl⟩ m h
state_before: case mp
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
⊢ X s ^ n ∣ φ → ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0

tactic: rw [coeff_mul, Finset.sum_eq_zero]
state_before: case mp.intro
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
m : σ →₀ ℕ
h : ↑m s < n
⊢ ↑(coeff R m) (X s ^ n * φ) = 0

tactic: rintro ⟨i, j⟩ hij
state_before: case mp.intro
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
m : σ →₀ ℕ
h : ↑m s < n
⊢ ∀ (x : (σ →₀ ℕ) × (σ →₀ ℕ)), x ∈ antidiagonal m → ↑(coeff R x.fst) (X s ^ n) * ↑(coeff R x.snd) φ = 0

tactic: rw [coeff_X_pow, if_neg, MulZeroClass.zero_mul]
state_before: case mp.intro.mk
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
m : σ →₀ ℕ
h : ↑m s < n
i j : σ →₀ ℕ
hij : (i, j) ∈ antidiagonal m
⊢ ↑(coeff R (i, j).fst) (X s ^ n) * ↑(coeff R (i, j).snd) φ = 0

tactic: contrapose! h
state_before: case mp.intro.mk.hnc
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
m : σ →₀ ℕ
h : ↑m s < n
i j : σ →₀ ℕ
hij : (i, j) ∈ antidiagonal m
⊢ ¬(i, j).fst = single s n

tactic: subst i
state_before: case mp.intro.mk.hnc
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
m i j : σ →₀ ℕ
hij : (i, j) ∈ antidiagonal m
h : i = single s n
⊢ n ≤ ↑m s

tactic: rw [Finsupp.mem_antidiagonal] at hij
state_before: case mp.intro.mk.hnc
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
m j : σ →₀ ℕ
hij : (single s n, j) ∈ antidiagonal m
⊢ n ≤ ↑m s

tactic: rw [← hij, Finsupp.add_apply, Finsupp.single_eq_same]
state_before: case mp.intro.mk.hnc
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
m j : σ →₀ ℕ
hij : (single s n, j).fst + (single s n, j).snd = m
⊢ n ≤ ↑m s

tactic: exact Nat.le_add_right n _
state_before: case mp.intro.mk.hnc
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
m j : σ →₀ ℕ
hij : (single s n, j).fst + (single s n, j).snd = m
⊢ n ≤ n + ↑(single s n, j).snd s

tactic: intro h
state_before: case mpr
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
⊢ (∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0) → X s ^ n ∣ φ

tactic: refine' ⟨fun m => coeff R (m + single s n) φ, _⟩
state_before: case mpr
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
⊢ X s ^ n ∣ φ

tactic: ext m
state_before: case mpr
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
⊢ φ = X s ^ n * fun m => ↑(coeff R (m + single s n)) φ

tactic: by_cases H : m - single s n + single s n = m
state_before: case mpr.h
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
⊢ ↑(coeff R m) φ = ↑(coeff R m) (X s ^ n * fun m => ↑(coeff R (m + single s n)) φ)

tactic: rw [coeff_mul, Finset.sum_eq_single (single s n, m - single s n)]
state_before: case pos
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : m - single s n + single s n = m
⊢ ↑(coeff R m) φ = ↑(coeff R m) (X s ^ n * fun m => ↑(coeff R (m + single s n)) φ)

tactic: rw [coeff_X_pow, if_pos rfl, one_mul]
state_before: case pos
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : m - single s n + single s n = m
⊢ ↑(coeff R m) φ =
    ↑(coeff R (single s n, m - single s n).fst) (X s ^ n) *
      ↑(coeff R (single s n, m - single s n).snd) fun m => ↑(coeff R (m + single s n)) φ

tactic: simpa using congr_arg (fun m : σ →₀ ℕ => coeff R m φ) H.symm
state_before: case pos
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : m - single s n + single s n = m
⊢ ↑(coeff R m) φ = ↑(coeff R (single s n, m - single s n).snd) fun m => ↑(coeff R (m + single s n)) φ

tactic: rintro ⟨i, j⟩ hij hne
state_before: case pos.h₀
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : m - single s n + single s n = m
⊢ ∀ (b : (σ →₀ ℕ) × (σ →₀ ℕ)),
    b ∈ antidiagonal m →
      b ≠ (single s n, m - single s n) →
        (↑(coeff R b.fst) (X s ^ n) * ↑(coeff R b.snd) fun m => ↑(coeff R (m + single s n)) φ) = 0

tactic: rw [Finsupp.mem_antidiagonal] at hij
state_before: case pos.h₀.mk
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : m - single s n + single s n = m
i j : σ →₀ ℕ
hij : (i, j) ∈ antidiagonal m
hne : (i, j) ≠ (single s n, m - single s n)
⊢ (↑(coeff R (i, j).fst) (X s ^ n) * ↑(coeff R (i, j).snd) fun m => ↑(coeff R (m + single s n)) φ) = 0

tactic: rw [coeff_X_pow]
state_before: case pos.h₀.mk
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : m - single s n + single s n = m
i j : σ →₀ ℕ
hij : (i, j).fst + (i, j).snd = m
hne : (i, j) ≠ (single s n, m - single s n)
⊢ (↑(coeff R (i, j).fst) (X s ^ n) * ↑(coeff R (i, j).snd) fun m => ↑(coeff R (m + single s n)) φ) = 0

tactic: split_ifs with hi
state_before: case pos.h₀.mk
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : m - single s n + single s n = m
i j : σ →₀ ℕ
hij : (i, j).fst + (i, j).snd = m
hne : (i, j) ≠ (single s n, m - single s n)
⊢ ((if (i, j).fst = single s n then 1 else 0) * ↑(coeff R (i, j).snd) fun m => ↑(coeff R (m + single s n)) φ) = 0

tactic: exfalso
state_before: case pos.h₀.mk.inl
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : m - single s n + single s n = m
i j : σ →₀ ℕ
hij : (i, j).fst + (i, j).snd = m
hne : (i, j) ≠ (single s n, m - single s n)
hi : (i, j).fst = single s n
⊢ (1 * ↑(coeff R (i, j).snd) fun m => ↑(coeff R (m + single s n)) φ) = 0

tactic: apply hne
state_before: case pos.h₀.mk.inl.h
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : m - single s n + single s n = m
i j : σ →₀ ℕ
hij : (i, j).fst + (i, j).snd = m
hne : (i, j) ≠ (single s n, m - single s n)
hi : (i, j).fst = single s n
⊢ False

tactic: rw [← hij, ← hi, Prod.mk.inj_iff]
state_before: case pos.h₀.mk.inl.h
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : m - single s n + single s n = m
i j : σ →₀ ℕ
hij : (i, j).fst + (i, j).snd = m
hne : (i, j) ≠ (single s n, m - single s n)
hi : (i, j).fst = single s n
⊢ (i, j) = (single s n, m - single s n)

tactic: refine' ⟨rfl, _⟩
state_before: case pos.h₀.mk.inl.h
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : m - single s n + single s n = m
i j : σ →₀ ℕ
hij : (i, j).fst + (i, j).snd = m
hne : (i, j) ≠ (single s n, m - single s n)
hi : (i, j).fst = single s n
⊢ i = (i, j).fst ∧ j = (i, j).fst + (i, j).snd - (i, j).fst

tactic: ext t
state_before: case pos.h₀.mk.inl.h
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : m - single s n + single s n = m
i j : σ →₀ ℕ
hij : (i, j).fst + (i, j).snd = m
hne : (i, j) ≠ (single s n, m - single s n)
hi : (i, j).fst = single s n
⊢ j = (i, j).fst + (i, j).snd - (i, j).fst

tactic: simp only [add_tsub_cancel_left, Finsupp.add_apply, Finsupp.tsub_apply]
state_before: case pos.h₀.mk.inl.h.h
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : m - single s n + single s n = m
i j : σ →₀ ℕ
hij : (i, j).fst + (i, j).snd = m
hne : (i, j) ≠ (single s n, m - single s n)
hi : (i, j).fst = single s n
t : σ
⊢ ↑j t = ↑((i, j).fst + (i, j).snd - (i, j).fst) t

tactic: exact MulZeroClass.zero_mul _
state_before: case pos.h₀.mk.inr
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : m - single s n + single s n = m
i j : σ →₀ ℕ
hij : (i, j).fst + (i, j).snd = m
hne : (i, j) ≠ (single s n, m - single s n)
hi : ¬(i, j).fst = single s n
⊢ (0 * ↑(coeff R (i, j).snd) fun m => ↑(coeff R (m + single s n)) φ) = 0

tactic: intro hni
state_before: case pos.h₁
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : m - single s n + single s n = m
⊢ ¬(single s n, m - single s n) ∈ antidiagonal m →
    (↑(coeff R (single s n, m - single s n).fst) (X s ^ n) *
        ↑(coeff R (single s n, m - single s n).snd) fun m => ↑(coeff R (m + single s n)) φ) =
      0

tactic: exfalso
state_before: case pos.h₁
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : m - single s n + single s n = m
hni : ¬(single s n, m - single s n) ∈ antidiagonal m
⊢ (↑(coeff R (single s n, m - single s n).fst) (X s ^ n) *
      ↑(coeff R (single s n, m - single s n).snd) fun m => ↑(coeff R (m + single s n)) φ) =
    0

tactic: apply hni
state_before: case pos.h₁.h
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : m - single s n + single s n = m
hni : ¬(single s n, m - single s n) ∈ antidiagonal m
⊢ False

tactic: rwa [Finsupp.mem_antidiagonal, add_comm]
state_before: case pos.h₁.h
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : m - single s n + single s n = m
hni : ¬(single s n, m - single s n) ∈ antidiagonal m
⊢ (single s n, m - single s n) ∈ antidiagonal m

tactic: rw [h, coeff_mul, Finset.sum_eq_zero]
state_before: case neg
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : ¬m - single s n + single s n = m
⊢ ↑(coeff R m) φ = ↑(coeff R m) (X s ^ n * fun m => ↑(coeff R (m + single s n)) φ)

tactic: rintro ⟨i, j⟩ hij
state_before: case neg
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : ¬m - single s n + single s n = m
⊢ ∀ (x : (σ →₀ ℕ) × (σ →₀ ℕ)),
    x ∈ antidiagonal m → (↑(coeff R x.fst) (X s ^ n) * ↑(coeff R x.snd) fun m => ↑(coeff R (m + single s n)) φ) = 0

tactic: rw [Finsupp.mem_antidiagonal] at hij
state_before: case neg.mk
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : ¬m - single s n + single s n = m
i j : σ →₀ ℕ
hij : (i, j) ∈ antidiagonal m
⊢ (↑(coeff R (i, j).fst) (X s ^ n) * ↑(coeff R (i, j).snd) fun m => ↑(coeff R (m + single s n)) φ) = 0

tactic: rw [coeff_X_pow]
state_before: case neg.mk
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : ¬m - single s n + single s n = m
i j : σ →₀ ℕ
hij : (i, j).fst + (i, j).snd = m
⊢ (↑(coeff R (i, j).fst) (X s ^ n) * ↑(coeff R (i, j).snd) fun m => ↑(coeff R (m + single s n)) φ) = 0

tactic: split_ifs with hi
state_before: case neg.mk
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : ¬m - single s n + single s n = m
i j : σ →₀ ℕ
hij : (i, j).fst + (i, j).snd = m
⊢ ((if (i, j).fst = single s n then 1 else 0) * ↑(coeff R (i, j).snd) fun m => ↑(coeff R (m + single s n)) φ) = 0

tactic: exfalso
state_before: case neg.mk.inl
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : ¬m - single s n + single s n = m
i j : σ →₀ ℕ
hij : (i, j).fst + (i, j).snd = m
hi : (i, j).fst = single s n
⊢ (1 * ↑(coeff R (i, j).snd) fun m => ↑(coeff R (m + single s n)) φ) = 0

tactic: apply H
state_before: case neg.mk.inl.h
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : ¬m - single s n + single s n = m
i j : σ →₀ ℕ
hij : (i, j).fst + (i, j).snd = m
hi : (i, j).fst = single s n
⊢ False

tactic: rw [← hij, hi]
state_before: case neg.mk.inl.h
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : ¬m - single s n + single s n = m
i j : σ →₀ ℕ
hij : (i, j).fst + (i, j).snd = m
hi : (i, j).fst = single s n
⊢ m - single s n + single s n = m

tactic: ext
state_before: case neg.mk.inl.h
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : ¬m - single s n + single s n = m
i j : σ →₀ ℕ
hij : (i, j).fst + (i, j).snd = m
hi : (i, j).fst = single s n
⊢ single s n + (i, j).snd - single s n + single s n = single s n + (i, j).snd

tactic: rw [coe_add, coe_add, Pi.add_apply, Pi.add_apply, add_tsub_cancel_left, add_comm]
state_before: case neg.mk.inl.h.h
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : ¬m - single s n + single s n = m
i j : σ →₀ ℕ
hij : (i, j).fst + (i, j).snd = m
hi : (i, j).fst = single s n
a✝ : σ
⊢ ↑(single s n + (i, j).snd - single s n + single s n) a✝ = ↑(single s n + (i, j).snd) a✝

tactic: exact MulZeroClass.zero_mul _
state_before: case neg.mk.inr
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : ¬m - single s n + single s n = m
i j : σ →₀ ℕ
hij : (i, j).fst + (i, j).snd = m
hi : ¬(i, j).fst = single s n
⊢ (0 * ↑(coeff R (i, j).snd) fun m => ↑(coeff R (m + single s n)) φ) = 0

tactic: contrapose! H
state_before: case neg.a
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : ¬m - single s n + single s n = m
⊢ ↑m s < n

tactic: ext t
state_before: case neg.a
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : n ≤ ↑m s
⊢ m - single s n + single s n = m

tactic: by_cases hst : s = t
state_before: case neg.a.h
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : n ≤ ↑m s
t : σ
⊢ ↑(m - single s n + single s n) t = ↑m t

tactic: subst t
state_before: case pos
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : n ≤ ↑m s
t : σ
hst : s = t
⊢ ↑(m - single s n + single s n) t = ↑m t

tactic: simpa using tsub_add_cancel_of_le H
state_before: case pos
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : n ≤ ↑m s
⊢ ↑(m - single s n + single s n) s = ↑m s

tactic: simp [Finsupp.single_apply, hst]
state_before: case neg
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
n : ℕ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < n → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
H : n ≤ ↑m s
t : σ
hst : ¬s = t
⊢ ↑(m - single s n + single s n) t = ↑m t