l3lab/ntp-mathlib huggingface dataset:
theorem mapRange_def [∀ (i) (x : β₁ i), Decidable (x ≠ 0)] {f : ∀ i, β₁ i → β₂ i}
    {hf : ∀ i, f i 0 = 0} {g : Π₀ i, β₁ i} :
    mapRange f hf g = mk g.support fun i => f i.1 (g i.1) := by
  ext i
  by_cases h : g i ≠ 0 <;> 

Proof state:
case pos
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
inst✝² : (i : ι) → Zero (β₁ i)
inst✝¹ : (i : ι) → Zero (β₂ i)
inst✝ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
g : Π₀ (i : ι), β₁ i
i : ι
h : g i ≠ 0
⊢ (mapRange f hf g) i = (mk (support g) fun i => f (↑i) (g ↑i)) i

Next tactic:
simp at h
theorem mapRange_def [∀ (i) (x : β₁ i), Decidable (x ≠ 0)] {f : ∀ i, β₁ i → β₂ i}
    {hf : ∀ i, f i 0 = 0} {g : Π₀ i, β₁ i} :
    mapRange f hf g = mk g.support fun i => f i.1 (g i.1) := by
  ext i
  by_cases h : g i ≠ 0 <;> 

Proof state:
case neg
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
inst✝² : (i : ι) → Zero (β₁ i)
inst✝¹ : (i : ι) → Zero (β₂ i)
inst✝ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
g : Π₀ (i : ι), β₁ i
i : ι
h : ¬g i ≠ 0
⊢ (mapRange f hf g) i = (mk (support g) fun i => f (↑i) (g ↑i)) i

Next tactic:
simp at h
theorem mapRange_def [∀ (i) (x : β₁ i), Decidable (x ≠ 0)] {f : ∀ i, β₁ i → β₂ i}
    {hf : ∀ i, f i 0 = 0} {g : Π₀ i, β₁ i} :
    mapRange f hf g = mk g.support fun i => f i.1 (g i.1) := by
  ext i
  by_cases h : g i ≠ 0 <;> simp at h <;> 

Proof state:
case pos
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
inst✝² : (i : ι) → Zero (β₁ i)
inst✝¹ : (i : ι) → Zero (β₂ i)
inst✝ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
g : Π₀ (i : ι), β₁ i
i : ι
h : ¬g i = 0
⊢ (mapRange f hf g) i = (mk (support g) fun i => f (↑i) (g ↑i)) i

Next tactic:
simp [h, hf]
theorem mapRange_def [∀ (i) (x : β₁ i), Decidable (x ≠ 0)] {f : ∀ i, β₁ i → β₂ i}
    {hf : ∀ i, f i 0 = 0} {g : Π₀ i, β₁ i} :
    mapRange f hf g = mk g.support fun i => f i.1 (g i.1) := by
  ext i
  by_cases h : g i ≠ 0 <;> simp at h <;> 

Proof state:
case neg
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
inst✝² : (i : ι) → Zero (β₁ i)
inst✝¹ : (i : ι) → Zero (β₂ i)
inst✝ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
g : Π₀ (i : ι), β₁ i
i : ι
h : g i = 0
⊢ (mapRange f hf g) i = (mk (support g) fun i => f (↑i) (g ↑i)) i

Next tactic:
simp [h, hf]
@[simp]
theorem mapRange_single {f : ∀ i, β₁ i → β₂ i} {hf : ∀ i, f i 0 = 0} {i : ι} {b : β₁ i} :
    mapRange f hf (single i b) = single i (f i b) :=
  DFinsupp.ext fun i' => by
    

Proof state:
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝³ : (i : ι) → Zero (β i)
inst✝² : (i : ι) → (x : β i) → Decidable (x ≠ 0)
inst✝¹ : (i : ι) → Zero (β₁ i)
inst✝ : (i : ι) → Zero (β₂ i)
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
i : ι
b : β₁ i
i' : ι
⊢ (mapRange f hf (single i b)) i' = (single i (f i b)) i'

Next tactic:
by_cases h : i = i'
@[simp]
theorem mapRange_single {f : ∀ i, β₁ i → β₂ i} {hf : ∀ i, f i 0 = 0} {i : ι} {b : β₁ i} :
    mapRange f hf (single i b) = single i (f i b) :=
  DFinsupp.ext fun i' => by
    by_cases h : i = i'
    · 

Proof state:
case pos
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝³ : (i : ι) → Zero (β i)
inst✝² : (i : ι) → (x : β i) → Decidable (x ≠ 0)
inst✝¹ : (i : ι) → Zero (β₁ i)
inst✝ : (i : ι) → Zero (β₂ i)
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
i : ι
b : β₁ i
i' : ι
h : i = i'
⊢ (mapRange f hf (single i b)) i' = (single i (f i b)) i'

Next tactic:
subst i'
@[simp]
theorem mapRange_single {f : ∀ i, β₁ i → β₂ i} {hf : ∀ i, f i 0 = 0} {i : ι} {b : β₁ i} :
    mapRange f hf (single i b) = single i (f i b) :=
  DFinsupp.ext fun i' => by
    by_cases h : i = i'
    · subst i'
      

Proof state:
case pos
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝³ : (i : ι) → Zero (β i)
inst✝² : (i : ι) → (x : β i) → Decidable (x ≠ 0)
inst✝¹ : (i : ι) → Zero (β₁ i)
inst✝ : (i : ι) → Zero (β₂ i)
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
i : ι
b : β₁ i
⊢ (mapRange f hf (single i b)) i = (single i (f i b)) i

Next tactic:
simp
@[simp]
theorem mapRange_single {f : ∀ i, β₁ i → β₂ i} {hf : ∀ i, f i 0 = 0} {i : ι} {b : β₁ i} :
    mapRange f hf (single i b) = single i (f i b) :=
  DFinsupp.ext fun i' => by
    by_cases h : i = i'
    · subst i'
      simp
    · 

Proof state:
case neg
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝³ : (i : ι) → Zero (β i)
inst✝² : (i : ι) → (x : β i) → Decidable (x ≠ 0)
inst✝¹ : (i : ι) → Zero (β₁ i)
inst✝ : (i : ι) → Zero (β₂ i)
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
i : ι
b : β₁ i
i' : ι
h : ¬i = i'
⊢ (mapRange f hf (single i b)) i' = (single i (f i b)) i'

Next tactic:
simp [h, hf]
theorem support_mapRange {f : ∀ i, β₁ i → β₂ i} {hf : ∀ i, f i 0 = 0} {g : Π₀ i, β₁ i} :
    (mapRange f hf g).support ⊆ g.support := by 

Proof state:
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝⁵ : (i : ι) → Zero (β i)
inst✝⁴ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
inst✝³ : (i : ι) → Zero (β₁ i)
inst✝² : (i : ι) → Zero (β₂ i)
inst✝¹ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝ : (i : ι) → (x : β₂ i) → Decidable (x ≠ 0)
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
g : Π₀ (i : ι), β₁ i
⊢ support (mapRange f hf g) ⊆ support g

Next tactic:
simp [mapRange_def]
theorem zipWith_def {ι : Type u} {β : ι → Type v} {β₁ : ι → Type v₁} {β₂ : ι → Type v₂}
    [dec : DecidableEq ι] [∀ i : ι, Zero (β i)] [∀ i : ι, Zero (β₁ i)] [∀ i : ι, Zero (β₂ i)]
    [∀ (i : ι) (x : β₁ i), Decidable (x ≠ 0)] [∀ (i : ι) (x : β₂ i), Decidable (x ≠ 0)]
    {f : ∀ i, β₁ i → β₂ i → β i} {hf : ∀ i, f i 0 0 = 0} {g₁ : Π₀ i, β₁ i} {g₂ : Π₀ i, β₂ i} :
    zipWith f hf g₁ g₂ = mk (g₁.support ∪ g₂.support) fun i => f i.1 (g₁ i.1) (g₂ i.1) := by
  

Proof state:
ι✝ : Type u
γ : Type w
β✝ : ι✝ → Type v
β₁✝ : ι✝ → Type v₁
β₂✝ : ι✝ → Type v₂
dec✝ : DecidableEq ι✝
inst✝¹⁰ : (i : ι✝) → Zero (β✝ i)
inst✝⁹ : (i : ι✝) → (x : β✝ i) → Decidable (x ≠ 0)
inst✝⁸ : (i : ι✝) → Zero (β₁✝ i)
inst✝⁷ : (i : ι✝) → Zero (β₂✝ i)
inst✝⁶ : (i : ι✝) → (x : β₁✝ i) → Decidable (x ≠ 0)
inst✝⁵ : (i : ι✝) → (x : β₂✝ i) → Decidable (x ≠ 0)
ι : Type u
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : (i : ι) → Zero (β₁ i)
inst✝² : (i : ι) → Zero (β₂ i)
inst✝¹ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝ : (i : ι) → (x : β₂ i) → Decidable (x ≠ 0)
f : (i : ι) → β₁ i → β₂ i → β i
hf : ∀ (i : ι), f i 0 0 = 0
g₁ : Π₀ (i : ι), β₁ i
g₂ : Π₀ (i : ι), β₂ i
⊢ zipWith f hf g₁ g₂ = mk (support g₁ ∪ support g₂) fun i => f (↑i) (g₁ ↑i) (g₂ ↑i)

Next tactic:
ext i
theorem zipWith_def {ι : Type u} {β : ι → Type v} {β₁ : ι → Type v₁} {β₂ : ι → Type v₂}
    [dec : DecidableEq ι] [∀ i : ι, Zero (β i)] [∀ i : ι, Zero (β₁ i)] [∀ i : ι, Zero (β₂ i)]
    [∀ (i : ι) (x : β₁ i), Decidable (x ≠ 0)] [∀ (i : ι) (x : β₂ i), Decidable (x ≠ 0)]
    {f : ∀ i, β₁ i → β₂ i → β i} {hf : ∀ i, f i 0 0 = 0} {g₁ : Π₀ i, β₁ i} {g₂ : Π₀ i, β₂ i} :
    zipWith f hf g₁ g₂ = mk (g₁.support ∪ g₂.support) fun i => f i.1 (g₁ i.1) (g₂ i.1) := by
  ext i
  

Proof state:
case h
ι✝ : Type u
γ : Type w
β✝ : ι✝ → Type v
β₁✝ : ι✝ → Type v₁
β₂✝ : ι✝ → Type v₂
dec✝ : DecidableEq ι✝
inst✝¹⁰ : (i : ι✝) → Zero (β✝ i)
inst✝⁹ : (i : ι✝) → (x : β✝ i) → Decidable (x ≠ 0)
inst✝⁸ : (i : ι✝) → Zero (β₁✝ i)
inst✝⁷ : (i : ι✝) → Zero (β₂✝ i)
inst✝⁶ : (i : ι✝) → (x : β₁✝ i) → Decidable (x ≠ 0)
inst✝⁵ : (i : ι✝) → (x : β₂✝ i) → Decidable (x ≠ 0)
ι : Type u
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : (i : ι) → Zero (β₁ i)
inst✝² : (i : ι) → Zero (β₂ i)
inst✝¹ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝ : (i : ι) → (x : β₂ i) → Decidable (x ≠ 0)
f : (i : ι) → β₁ i → β₂ i → β i
hf : ∀ (i : ι), f i 0 0 = 0
g₁ : Π₀ (i : ι), β₁ i
g₂ : Π₀ (i : ι), β₂ i
i : ι
⊢ (zipWith f hf g₁ g₂) i = (mk (support g₁ ∪ support g₂) fun i => f (↑i) (g₁ ↑i) (g₂ ↑i)) i

Next tactic:
by_cases h1 : g₁ i ≠ 0
theorem zipWith_def {ι : Type u} {β : ι → Type v} {β₁ : ι → Type v₁} {β₂ : ι → Type v₂}
    [dec : DecidableEq ι] [∀ i : ι, Zero (β i)] [∀ i : ι, Zero (β₁ i)] [∀ i : ι, Zero (β₂ i)]
    [∀ (i : ι) (x : β₁ i), Decidable (x ≠ 0)] [∀ (i : ι) (x : β₂ i), Decidable (x ≠ 0)]
    {f : ∀ i, β₁ i → β₂ i → β i} {hf : ∀ i, f i 0 0 = 0} {g₁ : Π₀ i, β₁ i} {g₂ : Π₀ i, β₂ i} :
    zipWith f hf g₁ g₂ = mk (g₁.support ∪ g₂.support) fun i => f i.1 (g₁ i.1) (g₂ i.1) := by
  ext i
  by_cases h1 : g₁ i ≠ 0 <;> 

Proof state:
case pos
ι✝ : Type u
γ : Type w
β✝ : ι✝ → Type v
β₁✝ : ι✝ → Type v₁
β₂✝ : ι✝ → Type v₂
dec✝ : DecidableEq ι✝
inst✝¹⁰ : (i : ι✝) → Zero (β✝ i)
inst✝⁹ : (i : ι✝) → (x : β✝ i) → Decidable (x ≠ 0)
inst✝⁸ : (i : ι✝) → Zero (β₁✝ i)
inst✝⁷ : (i : ι✝) → Zero (β₂✝ i)
inst✝⁶ : (i : ι✝) → (x : β₁✝ i) → Decidable (x ≠ 0)
inst✝⁵ : (i : ι✝) → (x : β₂✝ i) → Decidable (x ≠ 0)
ι : Type u
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : (i : ι) → Zero (β₁ i)
inst✝² : (i : ι) → Zero (β₂ i)
inst✝¹ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝ : (i : ι) → (x : β₂ i) → Decidable (x ≠ 0)
f : (i : ι) → β₁ i → β₂ i → β i
hf : ∀ (i : ι), f i 0 0 = 0
g₁ : Π₀ (i : ι), β₁ i
g₂ : Π₀ (i : ι), β₂ i
i : ι
h1 : g₁ i ≠ 0
⊢ (zipWith f hf g₁ g₂) i = (mk (support g₁ ∪ support g₂) fun i => f (↑i) (g₁ ↑i) (g₂ ↑i)) i

Next tactic:
by_cases h2 : g₂ i ≠ 0
theorem zipWith_def {ι : Type u} {β : ι → Type v} {β₁ : ι → Type v₁} {β₂ : ι → Type v₂}
    [dec : DecidableEq ι] [∀ i : ι, Zero (β i)] [∀ i : ι, Zero (β₁ i)] [∀ i : ι, Zero (β₂ i)]
    [∀ (i : ι) (x : β₁ i), Decidable (x ≠ 0)] [∀ (i : ι) (x : β₂ i), Decidable (x ≠ 0)]
    {f : ∀ i, β₁ i → β₂ i → β i} {hf : ∀ i, f i 0 0 = 0} {g₁ : Π₀ i, β₁ i} {g₂ : Π₀ i, β₂ i} :
    zipWith f hf g₁ g₂ = mk (g₁.support ∪ g₂.support) fun i => f i.1 (g₁ i.1) (g₂ i.1) := by
  ext i
  by_cases h1 : g₁ i ≠ 0 <;> 

Proof state:
case neg
ι✝ : Type u
γ : Type w
β✝ : ι✝ → Type v
β₁✝ : ι✝ → Type v₁
β₂✝ : ι✝ → Type v₂
dec✝ : DecidableEq ι✝
inst✝¹⁰ : (i : ι✝) → Zero (β✝ i)
inst✝⁹ : (i : ι✝) → (x : β✝ i) → Decidable (x ≠ 0)
inst✝⁸ : (i : ι✝) → Zero (β₁✝ i)
inst✝⁷ : (i : ι✝) → Zero (β₂✝ i)
inst✝⁶ : (i : ι✝) → (x : β₁✝ i) → Decidable (x ≠ 0)
inst✝⁵ : (i : ι✝) → (x : β₂✝ i) → Decidable (x ≠ 0)
ι : Type u
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : (i : ι) → Zero (β₁ i)
inst✝² : (i : ι) → Zero (β₂ i)
inst✝¹ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝ : (i : ι) → (x : β₂ i) → Decidable (x ≠ 0)
f : (i : ι) → β₁ i → β₂ i → β i
hf : ∀ (i : ι), f i 0 0 = 0
g₁ : Π₀ (i : ι), β₁ i
g₂ : Π₀ (i : ι), β₂ i
i : ι
h1 : ¬g₁ i ≠ 0
⊢ (zipWith f hf g₁ g₂) i = (mk (support g₁ ∪ support g₂) fun i => f (↑i) (g₁ ↑i) (g₂ ↑i)) i

Next tactic:
by_cases h2 : g₂ i ≠ 0
theorem zipWith_def {ι : Type u} {β : ι → Type v} {β₁ : ι → Type v₁} {β₂ : ι → Type v₂}
    [dec : DecidableEq ι] [∀ i : ι, Zero (β i)] [∀ i : ι, Zero (β₁ i)] [∀ i : ι, Zero (β₂ i)]
    [∀ (i : ι) (x : β₁ i), Decidable (x ≠ 0)] [∀ (i : ι) (x : β₂ i), Decidable (x ≠ 0)]
    {f : ∀ i, β₁ i → β₂ i → β i} {hf : ∀ i, f i 0 0 = 0} {g₁ : Π₀ i, β₁ i} {g₂ : Π₀ i, β₂ i} :
    zipWith f hf g₁ g₂ = mk (g₁.support ∪ g₂.support) fun i => f i.1 (g₁ i.1) (g₂ i.1) := by
  ext i
  by_cases h1 : g₁ i ≠ 0 <;> by_cases h2 : g₂ i ≠ 0 <;> 

Proof state:
case pos
ι✝ : Type u
γ : Type w
β✝ : ι✝ → Type v
β₁✝ : ι✝ → Type v₁
β₂✝ : ι✝ → Type v₂
dec✝ : DecidableEq ι✝
inst✝¹⁰ : (i : ι✝) → Zero (β✝ i)
inst✝⁹ : (i : ι✝) → (x : β✝ i) → Decidable (x ≠ 0)
inst✝⁸ : (i : ι✝) → Zero (β₁✝ i)
inst✝⁷ : (i : ι✝) → Zero (β₂✝ i)
inst✝⁶ : (i : ι✝) → (x : β₁✝ i) → Decidable (x ≠ 0)
inst✝⁵ : (i : ι✝) → (x : β₂✝ i) → Decidable (x ≠ 0)
ι : Type u
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : (i : ι) → Zero (β₁ i)
inst✝² : (i : ι) → Zero (β₂ i)
inst✝¹ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝ : (i : ι) → (x : β₂ i) → Decidable (x ≠ 0)
f : (i : ι) → β₁ i → β₂ i → β i
hf : ∀ (i : ι), f i 0 0 = 0
g₁ : Π₀ (i : ι), β₁ i
g₂ : Π₀ (i : ι), β₂ i
i : ι
h1 : g₁ i ≠ 0
h2 : g₂ i ≠ 0
⊢ (zipWith f hf g₁ g₂) i = (mk (support g₁ ∪ support g₂) fun i => f (↑i) (g₁ ↑i) (g₂ ↑i)) i

Next tactic:
simp only [not_not, Ne.def] at h1 h2
theorem zipWith_def {ι : Type u} {β : ι → Type v} {β₁ : ι → Type v₁} {β₂ : ι → Type v₂}
    [dec : DecidableEq ι] [∀ i : ι, Zero (β i)] [∀ i : ι, Zero (β₁ i)] [∀ i : ι, Zero (β₂ i)]
    [∀ (i : ι) (x : β₁ i), Decidable (x ≠ 0)] [∀ (i : ι) (x : β₂ i), Decidable (x ≠ 0)]
    {f : ∀ i, β₁ i → β₂ i → β i} {hf : ∀ i, f i 0 0 = 0} {g₁ : Π₀ i, β₁ i} {g₂ : Π₀ i, β₂ i} :
    zipWith f hf g₁ g₂ = mk (g₁.support ∪ g₂.support) fun i => f i.1 (g₁ i.1) (g₂ i.1) := by
  ext i
  by_cases h1 : g₁ i ≠ 0 <;> by_cases h2 : g₂ i ≠ 0 <;> 

Proof state:
case neg
ι✝ : Type u
γ : Type w
β✝ : ι✝ → Type v
β₁✝ : ι✝ → Type v₁
β₂✝ : ι✝ → Type v₂
dec✝ : DecidableEq ι✝
inst✝¹⁰ : (i : ι✝) → Zero (β✝ i)
inst✝⁹ : (i : ι✝) → (x : β✝ i) → Decidable (x ≠ 0)
inst✝⁸ : (i : ι✝) → Zero (β₁✝ i)
inst✝⁷ : (i : ι✝) → Zero (β₂✝ i)
inst✝⁶ : (i : ι✝) → (x : β₁✝ i) → Decidable (x ≠ 0)
inst✝⁵ : (i : ι✝) → (x : β₂✝ i) → Decidable (x ≠ 0)
ι : Type u
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : (i : ι) → Zero (β₁ i)
inst✝² : (i : ι) → Zero (β₂ i)
inst✝¹ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝ : (i : ι) → (x : β₂ i) → Decidable (x ≠ 0)
f : (i : ι) → β₁ i → β₂ i → β i
hf : ∀ (i : ι), f i 0 0 = 0
g₁ : Π₀ (i : ι), β₁ i
g₂ : Π₀ (i : ι), β₂ i
i : ι
h1 : g₁ i ≠ 0
h2 : ¬g₂ i ≠ 0
⊢ (zipWith f hf g₁ g₂) i = (mk (support g₁ ∪ support g₂) fun i => f (↑i) (g₁ ↑i) (g₂ ↑i)) i

Next tactic:
simp only [not_not, Ne.def] at h1 h2
theorem zipWith_def {ι : Type u} {β : ι → Type v} {β₁ : ι → Type v₁} {β₂ : ι → Type v₂}
    [dec : DecidableEq ι] [∀ i : ι, Zero (β i)] [∀ i : ι, Zero (β₁ i)] [∀ i : ι, Zero (β₂ i)]
    [∀ (i : ι) (x : β₁ i), Decidable (x ≠ 0)] [∀ (i : ι) (x : β₂ i), Decidable (x ≠ 0)]
    {f : ∀ i, β₁ i → β₂ i → β i} {hf : ∀ i, f i 0 0 = 0} {g₁ : Π₀ i, β₁ i} {g₂ : Π₀ i, β₂ i} :
    zipWith f hf g₁ g₂ = mk (g₁.support ∪ g₂.support) fun i => f i.1 (g₁ i.1) (g₂ i.1) := by
  ext i
  by_cases h1 : g₁ i ≠ 0 <;> by_cases h2 : g₂ i ≠ 0 <;> 

Proof state:
case pos
ι✝ : Type u
γ : Type w
β✝ : ι✝ → Type v
β₁✝ : ι✝ → Type v₁
β₂✝ : ι✝ → Type v₂
dec✝ : DecidableEq ι✝
inst✝¹⁰ : (i : ι✝) → Zero (β✝ i)
inst✝⁹ : (i : ι✝) → (x : β✝ i) → Decidable (x ≠ 0)
inst✝⁸ : (i : ι✝) → Zero (β₁✝ i)
inst✝⁷ : (i : ι✝) → Zero (β₂✝ i)
inst✝⁶ : (i : ι✝) → (x : β₁✝ i) → Decidable (x ≠ 0)
inst✝⁵ : (i : ι✝) → (x : β₂✝ i) → Decidable (x ≠ 0)
ι : Type u
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : (i : ι) → Zero (β₁ i)
inst✝² : (i : ι) → Zero (β₂ i)
inst✝¹ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝ : (i : ι) → (x : β₂ i) → Decidable (x ≠ 0)
f : (i : ι) → β₁ i → β₂ i → β i
hf : ∀ (i : ι), f i 0 0 = 0
g₁ : Π₀ (i : ι), β₁ i
g₂ : Π₀ (i : ι), β₂ i
i : ι
h1 : ¬g₁ i ≠ 0
h2 : g₂ i ≠ 0
⊢ (zipWith f hf g₁ g₂) i = (mk (support g₁ ∪ support g₂) fun i => f (↑i) (g₁ ↑i) (g₂ ↑i)) i

Next tactic:
simp only [not_not, Ne.def] at h1 h2
theorem zipWith_def {ι : Type u} {β : ι → Type v} {β₁ : ι → Type v₁} {β₂ : ι → Type v₂}
    [dec : DecidableEq ι] [∀ i : ι, Zero (β i)] [∀ i : ι, Zero (β₁ i)] [∀ i : ι, Zero (β₂ i)]
    [∀ (i : ι) (x : β₁ i), Decidable (x ≠ 0)] [∀ (i : ι) (x : β₂ i), Decidable (x ≠ 0)]
    {f : ∀ i, β₁ i → β₂ i → β i} {hf : ∀ i, f i 0 0 = 0} {g₁ : Π₀ i, β₁ i} {g₂ : Π₀ i, β₂ i} :
    zipWith f hf g₁ g₂ = mk (g₁.support ∪ g₂.support) fun i => f i.1 (g₁ i.1) (g₂ i.1) := by
  ext i
  by_cases h1 : g₁ i ≠ 0 <;> by_cases h2 : g₂ i ≠ 0 <;> 

Proof state:
case neg
ι✝ : Type u
γ : Type w
β✝ : ι✝ → Type v
β₁✝ : ι✝ → Type v₁
β₂✝ : ι✝ → Type v₂
dec✝ : DecidableEq ι✝
inst✝¹⁰ : (i : ι✝) → Zero (β✝ i)
inst✝⁹ : (i : ι✝) → (x : β✝ i) → Decidable (x ≠ 0)
inst✝⁸ : (i : ι✝) → Zero (β₁✝ i)
inst✝⁷ : (i : ι✝) → Zero (β₂✝ i)
inst✝⁶ : (i : ι✝) → (x : β₁✝ i) → Decidable (x ≠ 0)
inst✝⁵ : (i : ι✝) → (x : β₂✝ i) → Decidable (x ≠ 0)
ι : Type u
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : (i : ι) → Zero (β₁ i)
inst✝² : (i : ι) → Zero (β₂ i)
inst✝¹ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝ : (i : ι) → (x : β₂ i) → Decidable (x ≠ 0)
f : (i : ι) → β₁ i → β₂ i → β i
hf : ∀ (i : ι), f i 0 0 = 0
g₁ : Π₀ (i : ι), β₁ i
g₂ : Π₀ (i : ι), β₂ i
i : ι
h1 : ¬g₁ i ≠ 0
h2 : ¬g₂ i ≠ 0
⊢ (zipWith f hf g₁ g₂) i = (mk (support g₁ ∪ support g₂) fun i => f (↑i) (g₁ ↑i) (g₂ ↑i)) i

Next tactic:
simp only [not_not, Ne.def] at h1 h2
theorem zipWith_def {ι : Type u} {β : ι → Type v} {β₁ : ι → Type v₁} {β₂ : ι → Type v₂}
    [dec : DecidableEq ι] [∀ i : ι, Zero (β i)] [∀ i : ι, Zero (β₁ i)] [∀ i : ι, Zero (β₂ i)]
    [∀ (i : ι) (x : β₁ i), Decidable (x ≠ 0)] [∀ (i : ι) (x : β₂ i), Decidable (x ≠ 0)]
    {f : ∀ i, β₁ i → β₂ i → β i} {hf : ∀ i, f i 0 0 = 0} {g₁ : Π₀ i, β₁ i} {g₂ : Π₀ i, β₂ i} :
    zipWith f hf g₁ g₂ = mk (g₁.support ∪ g₂.support) fun i => f i.1 (g₁ i.1) (g₂ i.1) := by
  ext i
  by_cases h1 : g₁ i ≠ 0 <;> by_cases h2 : g₂ i ≠ 0 <;> simp only [not_not, Ne.def] at h1 h2 <;>
    

Proof state:
case pos
ι✝ : Type u
γ : Type w
β✝ : ι✝ → Type v
β₁✝ : ι✝ → Type v₁
β₂✝ : ι✝ → Type v₂
dec✝ : DecidableEq ι✝
inst✝¹⁰ : (i : ι✝) → Zero (β✝ i)
inst✝⁹ : (i : ι✝) → (x : β✝ i) → Decidable (x ≠ 0)
inst✝⁸ : (i : ι✝) → Zero (β₁✝ i)
inst✝⁷ : (i : ι✝) → Zero (β₂✝ i)
inst✝⁶ : (i : ι✝) → (x : β₁✝ i) → Decidable (x ≠ 0)
inst✝⁵ : (i : ι✝) → (x : β₂✝ i) → Decidable (x ≠ 0)
ι : Type u
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : (i : ι) → Zero (β₁ i)
inst✝² : (i : ι) → Zero (β₂ i)
inst✝¹ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝ : (i : ι) → (x : β₂ i) → Decidable (x ≠ 0)
f : (i : ι) → β₁ i → β₂ i → β i
hf : ∀ (i : ι), f i 0 0 = 0
g₁ : Π₀ (i : ι), β₁ i
g₂ : Π₀ (i : ι), β₂ i
i : ι
h1 : ¬g₁ i = 0
h2 : ¬g₂ i = 0
⊢ (zipWith f hf g₁ g₂) i = (mk (support g₁ ∪ support g₂) fun i => f (↑i) (g₁ ↑i) (g₂ ↑i)) i

Next tactic:
simp [h1, h2, hf]
theorem zipWith_def {ι : Type u} {β : ι → Type v} {β₁ : ι → Type v₁} {β₂ : ι → Type v₂}
    [dec : DecidableEq ι] [∀ i : ι, Zero (β i)] [∀ i : ι, Zero (β₁ i)] [∀ i : ι, Zero (β₂ i)]
    [∀ (i : ι) (x : β₁ i), Decidable (x ≠ 0)] [∀ (i : ι) (x : β₂ i), Decidable (x ≠ 0)]
    {f : ∀ i, β₁ i → β₂ i → β i} {hf : ∀ i, f i 0 0 = 0} {g₁ : Π₀ i, β₁ i} {g₂ : Π₀ i, β₂ i} :
    zipWith f hf g₁ g₂ = mk (g₁.support ∪ g₂.support) fun i => f i.1 (g₁ i.1) (g₂ i.1) := by
  ext i
  by_cases h1 : g₁ i ≠ 0 <;> by_cases h2 : g₂ i ≠ 0 <;> simp only [not_not, Ne.def] at h1 h2 <;>
    

Proof state:
case neg
ι✝ : Type u
γ : Type w
β✝ : ι✝ → Type v
β₁✝ : ι✝ → Type v₁
β₂✝ : ι✝ → Type v₂
dec✝ : DecidableEq ι✝
inst✝¹⁰ : (i : ι✝) → Zero (β✝ i)
inst✝⁹ : (i : ι✝) → (x : β✝ i) → Decidable (x ≠ 0)
inst✝⁸ : (i : ι✝) → Zero (β₁✝ i)
inst✝⁷ : (i : ι✝) → Zero (β₂✝ i)
inst✝⁶ : (i : ι✝) → (x : β₁✝ i) → Decidable (x ≠ 0)
inst✝⁵ : (i : ι✝) → (x : β₂✝ i) → Decidable (x ≠ 0)
ι : Type u
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : (i : ι) → Zero (β₁ i)
inst✝² : (i : ι) → Zero (β₂ i)
inst✝¹ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝ : (i : ι) → (x : β₂ i) → Decidable (x ≠ 0)
f : (i : ι) → β₁ i → β₂ i → β i
hf : ∀ (i : ι), f i 0 0 = 0
g₁ : Π₀ (i : ι), β₁ i
g₂ : Π₀ (i : ι), β₂ i
i : ι
h1 : ¬g₁ i = 0
h2 : g₂ i = 0
⊢ (zipWith f hf g₁ g₂) i = (mk (support g₁ ∪ support g₂) fun i => f (↑i) (g₁ ↑i) (g₂ ↑i)) i

Next tactic:
simp [h1, h2, hf]
theorem zipWith_def {ι : Type u} {β : ι → Type v} {β₁ : ι → Type v₁} {β₂ : ι → Type v₂}
    [dec : DecidableEq ι] [∀ i : ι, Zero (β i)] [∀ i : ι, Zero (β₁ i)] [∀ i : ι, Zero (β₂ i)]
    [∀ (i : ι) (x : β₁ i), Decidable (x ≠ 0)] [∀ (i : ι) (x : β₂ i), Decidable (x ≠ 0)]
    {f : ∀ i, β₁ i → β₂ i → β i} {hf : ∀ i, f i 0 0 = 0} {g₁ : Π₀ i, β₁ i} {g₂ : Π₀ i, β₂ i} :
    zipWith f hf g₁ g₂ = mk (g₁.support ∪ g₂.support) fun i => f i.1 (g₁ i.1) (g₂ i.1) := by
  ext i
  by_cases h1 : g₁ i ≠ 0 <;> by_cases h2 : g₂ i ≠ 0 <;> simp only [not_not, Ne.def] at h1 h2 <;>
    

Proof state:
case pos
ι✝ : Type u
γ : Type w
β✝ : ι✝ → Type v
β₁✝ : ι✝ → Type v₁
β₂✝ : ι✝ → Type v₂
dec✝ : DecidableEq ι✝
inst✝¹⁰ : (i : ι✝) → Zero (β✝ i)
inst✝⁹ : (i : ι✝) → (x : β✝ i) → Decidable (x ≠ 0)
inst✝⁸ : (i : ι✝) → Zero (β₁✝ i)
inst✝⁷ : (i : ι✝) → Zero (β₂✝ i)
inst✝⁶ : (i : ι✝) → (x : β₁✝ i) → Decidable (x ≠ 0)
inst✝⁵ : (i : ι✝) → (x : β₂✝ i) → Decidable (x ≠ 0)
ι : Type u
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : (i : ι) → Zero (β₁ i)
inst✝² : (i : ι) → Zero (β₂ i)
inst✝¹ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝ : (i : ι) → (x : β₂ i) → Decidable (x ≠ 0)
f : (i : ι) → β₁ i → β₂ i → β i
hf : ∀ (i : ι), f i 0 0 = 0
g₁ : Π₀ (i : ι), β₁ i
g₂ : Π₀ (i : ι), β₂ i
i : ι
h2 : ¬g₂ i = 0
h1 : g₁ i = 0
⊢ (zipWith f hf g₁ g₂) i = (mk (support g₁ ∪ support g₂) fun i => f (↑i) (g₁ ↑i) (g₂ ↑i)) i

Next tactic:
simp [h1, h2, hf]
theorem zipWith_def {ι : Type u} {β : ι → Type v} {β₁ : ι → Type v₁} {β₂ : ι → Type v₂}
    [dec : DecidableEq ι] [∀ i : ι, Zero (β i)] [∀ i : ι, Zero (β₁ i)] [∀ i : ι, Zero (β₂ i)]
    [∀ (i : ι) (x : β₁ i), Decidable (x ≠ 0)] [∀ (i : ι) (x : β₂ i), Decidable (x ≠ 0)]
    {f : ∀ i, β₁ i → β₂ i → β i} {hf : ∀ i, f i 0 0 = 0} {g₁ : Π₀ i, β₁ i} {g₂ : Π₀ i, β₂ i} :
    zipWith f hf g₁ g₂ = mk (g₁.support ∪ g₂.support) fun i => f i.1 (g₁ i.1) (g₂ i.1) := by
  ext i
  by_cases h1 : g₁ i ≠ 0 <;> by_cases h2 : g₂ i ≠ 0 <;> simp only [not_not, Ne.def] at h1 h2 <;>
    

Proof state:
case neg
ι✝ : Type u
γ : Type w
β✝ : ι✝ → Type v
β₁✝ : ι✝ → Type v₁
β₂✝ : ι✝ → Type v₂
dec✝ : DecidableEq ι✝
inst✝¹⁰ : (i : ι✝) → Zero (β✝ i)
inst✝⁹ : (i : ι✝) → (x : β✝ i) → Decidable (x ≠ 0)
inst✝⁸ : (i : ι✝) → Zero (β₁✝ i)
inst✝⁷ : (i : ι✝) → Zero (β₂✝ i)
inst✝⁶ : (i : ι✝) → (x : β₁✝ i) → Decidable (x ≠ 0)
inst✝⁵ : (i : ι✝) → (x : β₂✝ i) → Decidable (x ≠ 0)
ι : Type u
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : (i : ι) → Zero (β₁ i)
inst✝² : (i : ι) → Zero (β₂ i)
inst✝¹ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝ : (i : ι) → (x : β₂ i) → Decidable (x ≠ 0)
f : (i : ι) → β₁ i → β₂ i → β i
hf : ∀ (i : ι), f i 0 0 = 0
g₁ : Π₀ (i : ι), β₁ i
g₂ : Π₀ (i : ι), β₂ i
i : ι
h1 : g₁ i = 0
h2 : g₂ i = 0
⊢ (zipWith f hf g₁ g₂) i = (mk (support g₁ ∪ support g₂) fun i => f (↑i) (g₁ ↑i) (g₂ ↑i)) i

Next tactic:
simp [h1, h2, hf]
theorem support_zipWith {f : ∀ i, β₁ i → β₂ i → β i} {hf : ∀ i, f i 0 0 = 0} {g₁ : Π₀ i, β₁ i}
    {g₂ : Π₀ i, β₂ i} : (zipWith f hf g₁ g₂).support ⊆ g₁.support ∪ g₂.support := by
  

Proof state:
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝⁵ : (i : ι) → Zero (β i)
inst✝⁴ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
inst✝³ : (i : ι) → Zero (β₁ i)
inst✝² : (i : ι) → Zero (β₂ i)
inst✝¹ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝ : (i : ι) → (x : β₂ i) → Decidable (x ≠ 0)
f : (i : ι) → β₁ i → β₂ i → β i
hf : ∀ (i : ι), f i 0 0 = 0
g₁ : Π₀ (i : ι), β₁ i
g₂ : Π₀ (i : ι), β₂ i
⊢ support (zipWith f hf g₁ g₂) ⊆ support g₁ ∪ support g₂

Next tactic:
simp [zipWith_def]
theorem erase_def (i : ι) (f : Π₀ i, β i) : f.erase i = mk (f.support.erase i) fun j => f j.1 := by
  

Proof state:
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : Π₀ (i : ι), β i
⊢ erase i f = mk (Finset.erase (support f) i) fun j => f ↑j

Next tactic:
ext j