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

tactic: rw [H]
state_before: σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : ↑(constantCoeff σ R) φ = ↑u
n : σ →₀ ℕ
H : n = 0
⊢ ↑(coeff R n) (φ * invOfUnit φ u) = ↑(coeff R n) 1

tactic: simp [coeff_mul, support_single_ne_zero, h]
state_before: σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : ↑(constantCoeff σ R) φ = ↑u
n : σ →₀ ℕ
H : n = 0
⊢ ↑(coeff R 0) (φ * invOfUnit φ u) = ↑(coeff R 0) 1

tactic: have : ((0 : σ →₀ ℕ), n) ∈ n.antidiagonal := by rw [Finsupp.mem_antidiagonal, zero_add]
state_before: σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : ↑(constantCoeff σ R) φ = ↑u
n : σ →₀ ℕ
H : ¬n = 0
⊢ ↑(coeff R n) (φ * invOfUnit φ u) = ↑(coeff R n) 1

tactic: rw [coeff_one, if_neg H, coeff_mul, ← Finset.insert_erase this,
  Finset.sum_insert (Finset.not_mem_erase _ _), coeff_zero_eq_constantCoeff_apply, h,
  coeff_invOfUnit, if_neg H, neg_mul, mul_neg, Units.mul_inv_cancel_left, ←
  Finset.insert_erase this, Finset.sum_insert (Finset.not_mem_erase _ _),
  Finset.insert_erase this, if_neg (not_lt_of_ge <| le_rfl), zero_add, add_comm, ←
  sub_eq_add_neg, sub_eq_zero, Finset.sum_congr rfl]
state_before: σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : ↑(constantCoeff σ R) φ = ↑u
n : σ →₀ ℕ
H : ¬n = 0
this : (0, n) ∈ antidiagonal n
⊢ ↑(coeff R n) (φ * invOfUnit φ u) = ↑(coeff R n) 1

tactic: rintro ⟨i, j⟩ hij
state_before: σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : ↑(constantCoeff σ R) φ = ↑u
n : σ →₀ ℕ
H : ¬n = 0
this : (0, n) ∈ antidiagonal n
⊢ ∀ (x : (σ →₀ ℕ) × (σ →₀ ℕ)),
    x ∈ Finset.erase (antidiagonal n) (0, n) →
      ↑(coeff R x.fst) φ * ↑(coeff R x.snd) (invOfUnit φ u) =
        if x.snd < (0, n).snd then ↑(coeff R x.fst) φ * ↑(coeff R x.snd) (invOfUnit φ u) else 0

tactic: rw [Finset.mem_erase, Finsupp.mem_antidiagonal] at hij
state_before: case mk
σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : ↑(constantCoeff σ R) φ = ↑u
n : σ →₀ ℕ
H : ¬n = 0
this : (0, n) ∈ antidiagonal n
i j : σ →₀ ℕ
hij : (i, j) ∈ Finset.erase (antidiagonal n) (0, n)
⊢ ↑(coeff R (i, j).fst) φ * ↑(coeff R (i, j).snd) (invOfUnit φ u) =
    if (i, j).snd < (0, n).snd then ↑(coeff R (i, j).fst) φ * ↑(coeff R (i, j).snd) (invOfUnit φ u) else 0

tactic: cases' hij with h₁ h₂
state_before: case mk
σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : ↑(constantCoeff σ R) φ = ↑u
n : σ →₀ ℕ
H : ¬n = 0
this : (0, n) ∈ antidiagonal n
i j : σ →₀ ℕ
hij : (i, j) ≠ (0, n) ∧ (i, j).fst + (i, j).snd = n
⊢ ↑(coeff R (i, j).fst) φ * ↑(coeff R (i, j).snd) (invOfUnit φ u) =
    if (i, j).snd < (0, n).snd then ↑(coeff R (i, j).fst) φ * ↑(coeff R (i, j).snd) (invOfUnit φ u) else 0

tactic: subst n
state_before: case mk.intro
σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : ↑(constantCoeff σ R) φ = ↑u
n : σ →₀ ℕ
H : ¬n = 0
this : (0, n) ∈ antidiagonal n
i j : σ →₀ ℕ
h₁ : (i, j) ≠ (0, n)
h₂ : (i, j).fst + (i, j).snd = n
⊢ ↑(coeff R (i, j).fst) φ * ↑(coeff R (i, j).snd) (invOfUnit φ u) =
    if (i, j).snd < (0, n).snd then ↑(coeff R (i, j).fst) φ * ↑(coeff R (i, j).snd) (invOfUnit φ u) else 0

tactic: rw [if_pos]
state_before: case mk.intro
σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : ↑(constantCoeff σ R) φ = ↑u
i j : σ →₀ ℕ
H : ¬(i, j).fst + (i, j).snd = 0
this : (0, (i, j).fst + (i, j).snd) ∈ antidiagonal ((i, j).fst + (i, j).snd)
h₁ : (i, j) ≠ (0, (i, j).fst + (i, j).snd)
⊢ ↑(coeff R (i, j).fst) φ * ↑(coeff R (i, j).snd) (invOfUnit φ u) =
    if (i, j).snd < (0, (i, j).fst + (i, j).snd).snd then
      ↑(coeff R (i, j).fst) φ * ↑(coeff R (i, j).snd) (invOfUnit φ u)
    else 0

tactic: suffices (0 : _) + j < i + j by simpa
state_before: case mk.intro.hc
σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : ↑(constantCoeff σ R) φ = ↑u
i j : σ →₀ ℕ
H : ¬(i, j).fst + (i, j).snd = 0
this : (0, (i, j).fst + (i, j).snd) ∈ antidiagonal ((i, j).fst + (i, j).snd)
h₁ : (i, j) ≠ (0, (i, j).fst + (i, j).snd)
⊢ (i, j).snd < (0, (i, j).fst + (i, j).snd).snd

tactic: apply add_lt_add_right
state_before: case mk.intro.hc
σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : ↑(constantCoeff σ R) φ = ↑u
i j : σ →₀ ℕ
H : ¬(i, j).fst + (i, j).snd = 0
this : (0, (i, j).fst + (i, j).snd) ∈ antidiagonal ((i, j).fst + (i, j).snd)
h₁ : (i, j) ≠ (0, (i, j).fst + (i, j).snd)
⊢ 0 + j < i + j

tactic: constructor
state_before: case mk.intro.hc.bc
σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : ↑(constantCoeff σ R) φ = ↑u
i j : σ →₀ ℕ
H : ¬(i, j).fst + (i, j).snd = 0
this : (0, (i, j).fst + (i, j).snd) ∈ antidiagonal ((i, j).fst + (i, j).snd)
h₁ : (i, j) ≠ (0, (i, j).fst + (i, j).snd)
⊢ 0 < i

tactic: rw [Finsupp.mem_antidiagonal, zero_add]
state_before: σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : ↑(constantCoeff σ R) φ = ↑u
n : σ →₀ ℕ
H : ¬n = 0
⊢ (0, n) ∈ antidiagonal n

tactic: simpa
state_before: σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : ↑(constantCoeff σ R) φ = ↑u
i j : σ →₀ ℕ
H : ¬(i, j).fst + (i, j).snd = 0
this✝ : (0, (i, j).fst + (i, j).snd) ∈ antidiagonal ((i, j).fst + (i, j).snd)
h₁ : (i, j) ≠ (0, (i, j).fst + (i, j).snd)
this : 0 + j < i + j
⊢ (i, j).snd < (0, (i, j).fst + (i, j).snd).snd

tactic: intro s
state_before: case mk.intro.hc.bc.left
σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : ↑(constantCoeff σ R) φ = ↑u
i j : σ →₀ ℕ
H : ¬(i, j).fst + (i, j).snd = 0
this : (0, (i, j).fst + (i, j).snd) ∈ antidiagonal ((i, j).fst + (i, j).snd)
h₁ : (i, j) ≠ (0, (i, j).fst + (i, j).snd)
⊢ ∀ (i_1 : σ), PartialOrder.toPreorder.1.1 (↑0 i_1) (↑i i_1)

tactic: exact Nat.zero_le _
state_before: case mk.intro.hc.bc.left
σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : ↑(constantCoeff σ R) φ = ↑u
i j : σ →₀ ℕ
H : ¬(i, j).fst + (i, j).snd = 0
this : (0, (i, j).fst + (i, j).snd) ∈ antidiagonal ((i, j).fst + (i, j).snd)
h₁ : (i, j) ≠ (0, (i, j).fst + (i, j).snd)
s : σ
⊢ PartialOrder.toPreorder.1.1 (↑0 s) (↑i s)

tactic: intro H
state_before: case mk.intro.hc.bc.right
σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : ↑(constantCoeff σ R) φ = ↑u
i j : σ →₀ ℕ
H : ¬(i, j).fst + (i, j).snd = 0
this : (0, (i, j).fst + (i, j).snd) ∈ antidiagonal ((i, j).fst + (i, j).snd)
h₁ : (i, j) ≠ (0, (i, j).fst + (i, j).snd)
⊢ ¬∀ (i_1 : σ), PartialOrder.toPreorder.1.1 (↑i i_1) (↑0 i_1)

tactic: apply h₁
state_before: case mk.intro.hc.bc.right
σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : ↑(constantCoeff σ R) φ = ↑u
i j : σ →₀ ℕ
H✝ : ¬(i, j).fst + (i, j).snd = 0
this : (0, (i, j).fst + (i, j).snd) ∈ antidiagonal ((i, j).fst + (i, j).snd)
h₁ : (i, j) ≠ (0, (i, j).fst + (i, j).snd)
H : ∀ (i_1 : σ), PartialOrder.toPreorder.1.1 (↑i i_1) (↑0 i_1)
⊢ False

tactic: suffices i = 0 by simp [this]
state_before: case mk.intro.hc.bc.right
σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : ↑(constantCoeff σ R) φ = ↑u
i j : σ →₀ ℕ
H✝ : ¬(i, j).fst + (i, j).snd = 0
this : (0, (i, j).fst + (i, j).snd) ∈ antidiagonal ((i, j).fst + (i, j).snd)
h₁ : (i, j) ≠ (0, (i, j).fst + (i, j).snd)
H : ∀ (i_1 : σ), PartialOrder.toPreorder.1.1 (↑i i_1) (↑0 i_1)
⊢ (i, j) = (0, (i, j).fst + (i, j).snd)

tactic: ext1 s
state_before: case mk.intro.hc.bc.right
σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : ↑(constantCoeff σ R) φ = ↑u
i j : σ →₀ ℕ
H✝ : ¬(i, j).fst + (i, j).snd = 0
this : (0, (i, j).fst + (i, j).snd) ∈ antidiagonal ((i, j).fst + (i, j).snd)
h₁ : (i, j) ≠ (0, (i, j).fst + (i, j).snd)
H : ∀ (i_1 : σ), PartialOrder.toPreorder.1.1 (↑i i_1) (↑0 i_1)
⊢ i = 0

tactic: exact Nat.eq_zero_of_le_zero (H s)
state_before: case mk.intro.hc.bc.right.h
σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : ↑(constantCoeff σ R) φ = ↑u
i j : σ →₀ ℕ
H✝ : ¬(i, j).fst + (i, j).snd = 0
this : (0, (i, j).fst + (i, j).snd) ∈ antidiagonal ((i, j).fst + (i, j).snd)
h₁ : (i, j) ≠ (0, (i, j).fst + (i, j).snd)
H : ∀ (i_1 : σ), PartialOrder.toPreorder.1.1 (↑i i_1) (↑0 i_1)
s : σ
⊢ ↑i s = ↑0 s

tactic: simp [this]
state_before: σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
h : ↑(constantCoeff σ R) φ = ↑u
i j : σ →₀ ℕ
H✝ : ¬(i, j).fst + (i, j).snd = 0
this✝ : (0, (i, j).fst + (i, j).snd) ∈ antidiagonal ((i, j).fst + (i, j).snd)
h₁ : (i, j) ≠ (0, (i, j).fst + (i, j).snd)
H : ∀ (i_1 : σ), PartialOrder.toPreorder.1.1 (↑i i_1) (↑0 i_1)
this : i = 0
⊢ (i, j) = (0, (i, j).fst + (i, j).snd)