Theorem: Dfinsupp.induction
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: cases' f with f s
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
f : Π₀ (i : ι), β i
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
⊢ p f

tactic: induction' s using Trunc.induction_on with s
state_before: case mk'
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f : (i : ι) → β i
s : Trunc { s // ∀ (i : ι), i ∈ s ∨ f i = 0 }
⊢ p { toFun := f, support' := s }

tactic: cases' s with s H
state_before: case mk'.h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f : (i : ι) → β i
s : { s // ∀ (i : ι), i ∈ s ∨ f i = 0 }
⊢ p { toFun := f, support' := Trunc.mk s }

tactic: induction' s using Multiset.induction_on with i s ih generalizing f
state_before: case mk'.h.mk
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f : (i : ι) → β i
s : Multiset ι
H : ∀ (i : ι), i ∈ s ∨ f i = 0
⊢ p { toFun := f, support' := Trunc.mk { val := s, property := H } }

tactic: have H3 : single i _ + _ = (⟨f, Trunc.mk ⟨i ::ₘ s, H⟩⟩ : Π₀ i, β i) := single_add_erase _ _
state_before: case mk'.h.mk.cons
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f✝ : (i : ι) → β i
s✝ : Multiset ι
H✝ : ∀ (i : ι), i ∈ s✝ ∨ f✝ i = 0
i : ι
s : Multiset ι
ih :
  ∀ (f : (i : ι) → β i) (H : ∀ (i : ι), i ∈ s ∨ f i = 0),
    p { toFun := f, support' := Trunc.mk { val := s, property := H } }
f : (i : ι) → β i
H : ∀ (i_1 : ι), i_1 ∈ i ::ₘ s ∨ f i_1 = 0
H2 : p (erase i { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } })
⊢ p { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } }

tactic: rw [← H3]
state_before: case mk'.h.mk.cons
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f✝ : (i : ι) → β i
s✝ : Multiset ι
H✝ : ∀ (i : ι), i ∈ s✝ ∨ f✝ i = 0
i : ι
s : Multiset ι
ih :
  ∀ (f : (i : ι) → β i) (H : ∀ (i : ι), i ∈ s ∨ f i = 0),
    p { toFun := f, support' := Trunc.mk { val := s, property := H } }
f : (i : ι) → β i
H : ∀ (i_1 : ι), i_1 ∈ i ::ₘ s ∨ f i_1 = 0
H2 : p (erase i { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } })
H3 :
  single i (↑{ toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } } i) +
      erase i { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } } =
    { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } }
⊢ p { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } }

tactic: change p (single i (f i) + _)
state_before: case mk'.h.mk.cons
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f✝ : (i : ι) → β i
s✝ : Multiset ι
H✝ : ∀ (i : ι), i ∈ s✝ ∨ f✝ i = 0
i : ι
s : Multiset ι
ih :
  ∀ (f : (i : ι) → β i) (H : ∀ (i : ι), i ∈ s ∨ f i = 0),
    p { toFun := f, support' := Trunc.mk { val := s, property := H } }
f : (i : ι) → β i
H : ∀ (i_1 : ι), i_1 ∈ i ::ₘ s ∨ f i_1 = 0
H2 : p (erase i { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } })
H3 :
  single i (↑{ toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } } i) +
      erase i { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } } =
    { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } }
⊢ p
    (single i (↑{ toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } } i) +
      erase i { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } })

tactic: cases' Classical.em (f i = 0) with h h
state_before: case mk'.h.mk.cons
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f✝ : (i : ι) → β i
s✝ : Multiset ι
H✝ : ∀ (i : ι), i ∈ s✝ ∨ f✝ i = 0
i : ι
s : Multiset ι
ih :
  ∀ (f : (i : ι) → β i) (H : ∀ (i : ι), i ∈ s ∨ f i = 0),
    p { toFun := f, support' := Trunc.mk { val := s, property := H } }
f : (i : ι) → β i
H : ∀ (i_1 : ι), i_1 ∈ i ::ₘ s ∨ f i_1 = 0
H2 : p (erase i { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } })
H3 :
  single i (↑{ toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } } i) +
      erase i { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } } =
    { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } }
⊢ p (single i (f i) + erase i { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } })

tactic: refine' ha _ _ _ _ h H2
state_before: case mk'.h.mk.cons.inr
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f✝ : (i : ι) → β i
s✝ : Multiset ι
H✝ : ∀ (i : ι), i ∈ s✝ ∨ f✝ i = 0
i : ι
s : Multiset ι
ih :
  ∀ (f : (i : ι) → β i) (H : ∀ (i : ι), i ∈ s ∨ f i = 0),
    p { toFun := f, support' := Trunc.mk { val := s, property := H } }
f : (i : ι) → β i
H : ∀ (i_1 : ι), i_1 ∈ i ::ₘ s ∨ f i_1 = 0
H2 : p (erase i { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } })
H3 :
  single i (↑{ toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } } i) +
      erase i { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } } =
    { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } }
h : ¬f i = 0
⊢ p (single i (f i) + erase i { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } })

tactic: rw [erase_same]
state_before: case mk'.h.mk.cons.inr
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f✝ : (i : ι) → β i
s✝ : Multiset ι
H✝ : ∀ (i : ι), i ∈ s✝ ∨ f✝ i = 0
i : ι
s : Multiset ι
ih :
  ∀ (f : (i : ι) → β i) (H : ∀ (i : ι), i ∈ s ∨ f i = 0),
    p { toFun := f, support' := Trunc.mk { val := s, property := H } }
f : (i : ι) → β i
H : ∀ (i_1 : ι), i_1 ∈ i ::ₘ s ∨ f i_1 = 0
H2 : p (erase i { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } })
H3 :
  single i (↑{ toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } } i) +
      erase i { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } } =
    { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } }
h : ¬f i = 0
⊢ ↑(erase i { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } }) i = 0

tactic: have : f = 0 := funext fun i => (H i).resolve_left (Multiset.not_mem_zero _)
state_before: case mk'.h.mk.empty
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f✝ : (i : ι) → β i
s : Multiset ι
H✝ : ∀ (i : ι), i ∈ s ∨ f✝ i = 0
f : (i : ι) → β i
H : ∀ (i : ι), i ∈ 0 ∨ f i = 0
⊢ p { toFun := f, support' := Trunc.mk { val := 0, property := H } }

tactic: subst this
state_before: case mk'.h.mk.empty
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f✝ : (i : ι) → β i
s : Multiset ι
H✝ : ∀ (i : ι), i ∈ s ∨ f✝ i = 0
f : (i : ι) → β i
H : ∀ (i : ι), i ∈ 0 ∨ f i = 0
this : f = 0
⊢ p { toFun := f, support' := Trunc.mk { val := 0, property := H } }

tactic: exact h0
state_before: case mk'.h.mk.empty
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f : (i : ι) → β i
s : Multiset ι
H✝ : ∀ (i : ι), i ∈ s ∨ f i = 0
H : ∀ (i : ι), i ∈ 0 ∨ OfNat.ofNat 0 i = 0
⊢ p { toFun := 0, support' := Trunc.mk { val := 0, property := H } }

tactic: dsimp only [erase, Trunc.map, Trunc.bind, Trunc.liftOn, Trunc.lift_mk,
  Function.comp, Subtype.coe_mk]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f✝ : (i : ι) → β i
s✝ : Multiset ι
H✝ : ∀ (i : ι), i ∈ s✝ ∨ f✝ i = 0
i : ι
s : Multiset ι
ih :
  ∀ (f : (i : ι) → β i) (H : ∀ (i : ι), i ∈ s ∨ f i = 0),
    p { toFun := f, support' := Trunc.mk { val := s, property := H } }
f : (i : ι) → β i
H : ∀ (i_1 : ι), i_1 ∈ i ::ₘ s ∨ f i_1 = 0
⊢ p (erase i { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } })

tactic: have H3 : ∀ aux, (⟨fun j : ι => ite (j = i) 0 (f j), Trunc.mk ⟨i ::ₘ s, aux⟩⟩ : Π₀ i, β i) =
    ⟨fun j : ι => ite (j = i) 0 (f j), Trunc.mk ⟨s, H2⟩⟩ :=
  fun _ ↦ ext fun _ => rfl
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f✝ : (i : ι) → β i
s✝ : Multiset ι
H✝ : ∀ (i : ι), i ∈ s✝ ∨ f✝ i = 0
i : ι
s : Multiset ι
ih :
  ∀ (f : (i : ι) → β i) (H : ∀ (i : ι), i ∈ s ∨ f i = 0),
    p { toFun := f, support' := Trunc.mk { val := s, property := H } }
f : (i : ι) → β i
H : ∀ (i_1 : ι), i_1 ∈ i ::ₘ s ∨ f i_1 = 0
H2 : ∀ (j : ι), j ∈ s ∨ (if j = i then 0 else f j) = 0
⊢ p
    { toFun := fun j => if j = i then 0 else f j,
      support' :=
        Trunc.mk
          { val := i ::ₘ s,
            property :=
              (_ :
                ∀ (j : ι),
                  j ∈ ↑{ val := i ::ₘ s, property := H } ∨
                    (fun j =>
                          if j = i then 0
                          else toFun { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } } j)
                        j =
                      0) } }

tactic: rw [H3]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f✝ : (i : ι) → β i
s✝ : Multiset ι
H✝ : ∀ (i : ι), i ∈ s✝ ∨ f✝ i = 0
i : ι
s : Multiset ι
ih :
  ∀ (f : (i : ι) → β i) (H : ∀ (i : ι), i ∈ s ∨ f i = 0),
    p { toFun := f, support' := Trunc.mk { val := s, property := H } }
f : (i : ι) → β i
H : ∀ (i_1 : ι), i_1 ∈ i ::ₘ s ∨ f i_1 = 0
H2 : ∀ (j : ι), j ∈ s ∨ (if j = i then 0 else f j) = 0
H3 :
  ∀ (aux : ∀ (i_1 : ι), i_1 ∈ i ::ₘ s ∨ (fun j => if j = i then 0 else f j) i_1 = 0),
    { toFun := fun j => if j = i then 0 else f j, support' := Trunc.mk { val := i ::ₘ s, property := aux } } =
      { toFun := fun j => if j = i then 0 else f j, support' := Trunc.mk { val := s, property := H2 } }
⊢ p
    { toFun := fun j => if j = i then 0 else f j,
      support' :=
        Trunc.mk
          { val := i ::ₘ s,
            property :=
              (_ :
                ∀ (j : ι),
                  j ∈ ↑{ val := i ::ₘ s, property := H } ∨
                    (fun j =>
                          if j = i then 0
                          else toFun { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } } j)
                        j =
                      0) } }

tactic: apply ih
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f✝ : (i : ι) → β i
s✝ : Multiset ι
H✝ : ∀ (i : ι), i ∈ s✝ ∨ f✝ i = 0
i : ι
s : Multiset ι
ih :
  ∀ (f : (i : ι) → β i) (H : ∀ (i : ι), i ∈ s ∨ f i = 0),
    p { toFun := f, support' := Trunc.mk { val := s, property := H } }
f : (i : ι) → β i
H : ∀ (i_1 : ι), i_1 ∈ i ::ₘ s ∨ f i_1 = 0
H2 : ∀ (j : ι), j ∈ s ∨ (if j = i then 0 else f j) = 0
H3 :
  ∀ (aux : ∀ (i_1 : ι), i_1 ∈ i ::ₘ s ∨ (fun j => if j = i then 0 else f j) i_1 = 0),
    { toFun := fun j => if j = i then 0 else f j, support' := Trunc.mk { val := i ::ₘ s, property := aux } } =
      { toFun := fun j => if j = i then 0 else f j, support' := Trunc.mk { val := s, property := H2 } }
⊢ p { toFun := fun j => if j = i then 0 else f j, support' := Trunc.mk { val := s, property := H2 } }

tactic: intro j
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f✝ : (i : ι) → β i
s✝ : Multiset ι
H✝ : ∀ (i : ι), i ∈ s✝ ∨ f✝ i = 0
i : ι
s : Multiset ι
ih :
  ∀ (f : (i : ι) → β i) (H : ∀ (i : ι), i ∈ s ∨ f i = 0),
    p { toFun := f, support' := Trunc.mk { val := s, property := H } }
f : (i : ι) → β i
H : ∀ (i_1 : ι), i_1 ∈ i ::ₘ s ∨ f i_1 = 0
⊢ ∀ (j : ι), j ∈ s ∨ (if j = i then 0 else f j) = 0

tactic: cases' H j with H2 H2
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f✝ : (i : ι) → β i
s✝ : Multiset ι
H✝ : ∀ (i : ι), i ∈ s✝ ∨ f✝ i = 0
i : ι
s : Multiset ι
ih :
  ∀ (f : (i : ι) → β i) (H : ∀ (i : ι), i ∈ s ∨ f i = 0),
    p { toFun := f, support' := Trunc.mk { val := s, property := H } }
f : (i : ι) → β i
H : ∀ (i_1 : ι), i_1 ∈ i ::ₘ s ∨ f i_1 = 0
j : ι
⊢ j ∈ s ∨ (if j = i then 0 else f j) = 0

tactic: right
state_before: case inr
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f✝ : (i : ι) → β i
s✝ : Multiset ι
H✝ : ∀ (i : ι), i ∈ s✝ ∨ f✝ i = 0
i : ι
s : Multiset ι
ih :
  ∀ (f : (i : ι) → β i) (H : ∀ (i : ι), i ∈ s ∨ f i = 0),
    p { toFun := f, support' := Trunc.mk { val := s, property := H } }
f : (i : ι) → β i
H : ∀ (i_1 : ι), i_1 ∈ i ::ₘ s ∨ f i_1 = 0
j : ι
H2 : f j = 0
⊢ j ∈ s ∨ (if j = i then 0 else f j) = 0

tactic: split_ifs <;> [rfl; exact H2]
state_before: case inr.h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f✝ : (i : ι) → β i
s✝ : Multiset ι
H✝ : ∀ (i : ι), i ∈ s✝ ∨ f✝ i = 0
i : ι
s : Multiset ι
ih :
  ∀ (f : (i : ι) → β i) (H : ∀ (i : ι), i ∈ s ∨ f i = 0),
    p { toFun := f, support' := Trunc.mk { val := s, property := H } }
f : (i : ι) → β i
H : ∀ (i_1 : ι), i_1 ∈ i ::ₘ s ∨ f i_1 = 0
j : ι
H2 : f j = 0
⊢ (if j = i then 0 else f j) = 0

tactic: cases' Multiset.mem_cons.1 H2 with H3 H3
state_before: case inl
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f✝ : (i : ι) → β i
s✝ : Multiset ι
H✝ : ∀ (i : ι), i ∈ s✝ ∨ f✝ i = 0
i : ι
s : Multiset ι
ih :
  ∀ (f : (i : ι) → β i) (H : ∀ (i : ι), i ∈ s ∨ f i = 0),
    p { toFun := f, support' := Trunc.mk { val := s, property := H } }
f : (i : ι) → β i
H : ∀ (i_1 : ι), i_1 ∈ i ::ₘ s ∨ f i_1 = 0
j : ι
H2 : j ∈ i ::ₘ s
⊢ j ∈ s ∨ (if j = i then 0 else f j) = 0

tactic: right
state_before: case inl.inl
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f✝ : (i : ι) → β i
s✝ : Multiset ι
H✝ : ∀ (i : ι), i ∈ s✝ ∨ f✝ i = 0
i : ι
s : Multiset ι
ih :
  ∀ (f : (i : ι) → β i) (H : ∀ (i : ι), i ∈ s ∨ f i = 0),
    p { toFun := f, support' := Trunc.mk { val := s, property := H } }
f : (i : ι) → β i
H : ∀ (i_1 : ι), i_1 ∈ i ::ₘ s ∨ f i_1 = 0
j : ι
H2 : j ∈ i ::ₘ s
H3 : j = i
⊢ j ∈ s ∨ (if j = i then 0 else f j) = 0

tactic: exact if_pos H3
state_before: case inl.inl.h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f✝ : (i : ι) → β i
s✝ : Multiset ι
H✝ : ∀ (i : ι), i ∈ s✝ ∨ f✝ i = 0
i : ι
s : Multiset ι
ih :
  ∀ (f : (i : ι) → β i) (H : ∀ (i : ι), i ∈ s ∨ f i = 0),
    p { toFun := f, support' := Trunc.mk { val := s, property := H } }
f : (i : ι) → β i
H : ∀ (i_1 : ι), i_1 ∈ i ::ₘ s ∨ f i_1 = 0
j : ι
H2 : j ∈ i ::ₘ s
H3 : j = i
⊢ (if j = i then 0 else f j) = 0

tactic: left
state_before: case inl.inr
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f✝ : (i : ι) → β i
s✝ : Multiset ι
H✝ : ∀ (i : ι), i ∈ s✝ ∨ f✝ i = 0
i : ι
s : Multiset ι
ih :
  ∀ (f : (i : ι) → β i) (H : ∀ (i : ι), i ∈ s ∨ f i = 0),
    p { toFun := f, support' := Trunc.mk { val := s, property := H } }
f : (i : ι) → β i
H : ∀ (i_1 : ι), i_1 ∈ i ::ₘ s ∨ f i_1 = 0
j : ι
H2 : j ∈ i ::ₘ s
H3 : j ∈ s
⊢ j ∈ s ∨ (if j = i then 0 else f j) = 0

tactic: exact H3
state_before: case inl.inr.h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f✝ : (i : ι) → β i
s✝ : Multiset ι
H✝ : ∀ (i : ι), i ∈ s✝ ∨ f✝ i = 0
i : ι
s : Multiset ι
ih :
  ∀ (f : (i : ι) → β i) (H : ∀ (i : ι), i ∈ s ∨ f i = 0),
    p { toFun := f, support' := Trunc.mk { val := s, property := H } }
f : (i : ι) → β i
H : ∀ (i_1 : ι), i_1 ∈ i ::ₘ s ∨ f i_1 = 0
j : ι
H2 : j ∈ i ::ₘ s
H3 : j ∈ s
⊢ j ∈ s

tactic: rw [h, single_zero, zero_add]
state_before: case mk'.h.mk.cons.inl
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f✝ : (i : ι) → β i
s✝ : Multiset ι
H✝ : ∀ (i : ι), i ∈ s✝ ∨ f✝ i = 0
i : ι
s : Multiset ι
ih :
  ∀ (f : (i : ι) → β i) (H : ∀ (i : ι), i ∈ s ∨ f i = 0),
    p { toFun := f, support' := Trunc.mk { val := s, property := H } }
f : (i : ι) → β i
H : ∀ (i_1 : ι), i_1 ∈ i ::ₘ s ∨ f i_1 = 0
H2 : p (erase i { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } })
H3 :
  single i (↑{ toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } } i) +
      erase i { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } } =
    { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } }
h : f i = 0
⊢ p (single i (f i) + erase i { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } })

tactic: exact H2
state_before: case mk'.h.mk.cons.inl
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
p : (Π₀ (i : ι), β i) → Prop
h0 : p 0
ha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), ↑f i = 0 → b ≠ 0 → p f → p (single i b + f)
f✝ : (i : ι) → β i
s✝ : Multiset ι
H✝ : ∀ (i : ι), i ∈ s✝ ∨ f✝ i = 0
i : ι
s : Multiset ι
ih :
  ∀ (f : (i : ι) → β i) (H : ∀ (i : ι), i ∈ s ∨ f i = 0),
    p { toFun := f, support' := Trunc.mk { val := s, property := H } }
f : (i : ι) → β i
H : ∀ (i_1 : ι), i_1 ∈ i ::ₘ s ∨ f i_1 = 0
H2 : p (erase i { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } })
H3 :
  single i (↑{ toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } } i) +
      erase i { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } } =
    { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } }
h : f i = 0
⊢ p (erase i { toFun := f, support' := Trunc.mk { val := i ::ₘ s, property := H } })