File: Mathlib/Data/DFinsupp/Basic.lean

full_name: DFinsupp.support'
code: /-- A dependent function `Π i, β i` with finite support, with notation `Π₀ i, β i`.

Note that `DFinsupp.support` is the preferred API for accessing the support of the function,
`DFinsupp.support'` is an implementation detail that aids computability; see the implementation
notes in this file for more information. -/
structure DFinsupp [∀ i, Zero (β i)] : Type max u v where mk' ::
  /-- The underlying function of a dependent function with finite support (aka `DFinsupp`). -/
  toFun : ∀ i, β i
  /-- The support of a dependent function with finite support (aka `DFinsupp`). -/
  support' : Trunc { s : Multiset ι // ∀ i, i ∈ s ∨ toFun i = 0 }
goal: Trunc { s // ∀ (i : ι), i ∈ s ∨ self.toFun i = 0 }

full_name: DFinsupp
code: /-- A dependent function `Π i, β i` with finite support, with notation `Π₀ i, β i`.

Note that `DFinsupp.support` is the preferred API for accessing the support of the function,
`DFinsupp.support'` is an implementation detail that aids computability; see the implementation
notes in this file for more information. -/
structure DFinsupp [∀ i, Zero (β i)] : Type max u v where mk' ::
  /-- The underlying function of a dependent function with finite support (aka `DFinsupp`). -/
  toFun : ∀ i, β i
  /-- The support of a dependent function with finite support (aka `DFinsupp`). -/
  support' : Trunc { s : Multiset ι // ∀ i, i ∈ s ∨ toFun i = 0 }
goal: Type (max u v)

full_name: DFinsupp.toFun
code: /-- A dependent function `Π i, β i` with finite support, with notation `Π₀ i, β i`.

Note that `DFinsupp.support` is the preferred API for accessing the support of the function,
`DFinsupp.support'` is an implementation detail that aids computability; see the implementation
notes in this file for more information. -/
structure DFinsupp [∀ i, Zero (β i)] : Type max u v where mk' ::
  /-- The underlying function of a dependent function with finite support (aka `DFinsupp`). -/
  toFun : ∀ i, β i
  /-- The support of a dependent function with finite support (aka `DFinsupp`). -/
  support' : Trunc { s : Multiset ι // ∀ i, i ∈ s ∨ toFun i = 0 }
goal: β i

full_name: DFinsupp.mk'
code: /-- A dependent function `Π i, β i` with finite support, with notation `Π₀ i, β i`.

Note that `DFinsupp.support` is the preferred API for accessing the support of the function,
`DFinsupp.support'` is an implementation detail that aids computability; see the implementation
notes in this file for more information. -/
structure DFinsupp [∀ i, Zero (β i)] : Type max u v where mk' ::
  /-- The underlying function of a dependent function with finite support (aka `DFinsupp`). -/
  toFun : ∀ i, β i
  /-- The support of a dependent function with finite support (aka `DFinsupp`). -/
  support' : Trunc { s : Multiset ι // ∀ i, i ∈ s ∨ toFun i = 0 }
goal: DFinsupp β

full_name: «_aux_Mathlib_Data_DFinsupp_Basic___macroRules_termΠ₀_,__1»
code: /-- `Π₀ i, β i` denotes the type of dependent functions with finite support `DFinsupp β`. -/
notation3 "Π₀ "(...)", "r:(scoped f => DFinsupp f) => r
goal: Lean.Macro

full_name: DFinsupp.instDFunLike
code: instance instDFunLike : DFunLike (Π₀ i, β i) ι β 
goal: DFunLike (Π₀ (i : ι), β i) ι β

full_name: DFinsupp.instCoeFunForall
code: /-- Helper instance for when there are too many metavariables to apply `DFunLike.coeFunForall`
directly. -/
instance : CoeFun (Π₀ i, β i) fun _ => ∀ i, β i 
goal: CoeFun (Π₀ (i : ι), β i) fun x => (i : ι) → β i

full_name: DFinsupp.toFun_eq_coe
code: @[simp]
theorem toFun_eq_coe (f : Π₀ i, β i) : f.toFun = f 
goal: f.toFun = ⇑f

full_name: DFinsupp.ext
code: @[ext]
theorem ext {f g : Π₀ i, β i} (h : ∀ i, f i = g i) : f = g 
goal: f = g

full_name: DFinsupp.ne_iff
code: lemma ne_iff {f g : Π₀ i, β i} : f ≠ g ↔ ∃ i, f i ≠ g i 
goal: f ≠ g ↔ ∃ i, f i ≠ g i

full_name: DFinsupp.instZero
code: instance : Zero (Π₀ i, β i) 
goal: Zero (Π₀ (i : ι), β i)

full_name: DFinsupp.instInhabited
code: instance : Inhabited (Π₀ i, β i) 
goal: Inhabited (Π₀ (i : ι), β i)

full_name: DFinsupp.coe_mk'
code: @[simp, norm_cast] lemma coe_mk' (f : ∀ i, β i) (s) : ⇑(⟨f, s⟩ : Π₀ i, β i) = f 
goal: ⇑{ toFun := f, support' := s } = f

full_name: DFinsupp.coe_zero
code: @[simp, norm_cast] lemma coe_zero : ⇑(0 : Π₀ i, β i) = 0 
goal: ⇑0 = 0

full_name: DFinsupp.zero_apply
code: theorem zero_apply (i : ι) : (0 : Π₀ i, β i) i = 0 
goal: 0 i = 0

full_name: DFinsupp.mapRange
code: /-- The composition of `f : β₁ → β₂` and `g : Π₀ i, β₁ i` is
  `mapRange f hf g : Π₀ i, β₂ i`, well defined when `f 0 = 0`.

This preserves the structure on `f`, and exists in various bundled forms for when `f` is itself
bundled:

* `DFinsupp.mapRange.addMonoidHom`
* `DFinsupp.mapRange.addEquiv`
* `dfinsupp.mapRange.linearMap`
* `dfinsupp.mapRange.linearEquiv`
-/
def mapRange (f : ∀ i, β₁ i → β₂ i) (hf : ∀ i, f i 0 = 0) (x : Π₀ i, β₁ i) : Π₀ i, β₂ i 
goal: Π₀ (i : ι), β₂ i

full_name: DFinsupp.mapRange_apply
code: @[simp]
theorem mapRange_apply (f : ∀ i, β₁ i → β₂ i) (hf : ∀ i, f i 0 = 0) (g : Π₀ i, β₁ i) (i : ι) :
    mapRange f hf g i = f i (g i) 
goal: (DFinsupp.mapRange f hf g) i = f i (g i)

full_name: DFinsupp.mapRange_id
code: @[simp]
theorem mapRange_id (h : ∀ i, id (0 : β₁ i) = 0 := fun i => rfl) (g : Π₀ i : ι, β₁ i) :
    mapRange (fun i => (id : β₁ i → β₁ i)) h g = g 
goal: DFinsupp.mapRange (fun i => id) h g = g

full_name: DFinsupp.mapRange_comp
code: theorem mapRange_comp (f : ∀ i, β₁ i → β₂ i) (f₂ : ∀ i, β i → β₁ i) (hf : ∀ i, f i 0 = 0)
    (hf₂ : ∀ i, f₂ i 0 = 0) (h : ∀ i, (f i ∘ f₂ i) 0 = 0) (g : Π₀ i : ι, β i) :
    mapRange (fun i => f i ∘ f₂ i) h g = mapRange f hf (mapRange f₂ hf₂ g) 
goal: DFinsupp.mapRange (fun i => f i ∘ f₂ i) h g = DFinsupp.mapRange f hf (DFinsupp.mapRange f₂ hf₂ g)

full_name: DFinsupp.mapRange_zero
code: @[simp]
theorem mapRange_zero (f : ∀ i, β₁ i → β₂ i) (hf : ∀ i, f i 0 = 0) :
    mapRange f hf (0 : Π₀ i, β₁ i) = 0 
goal: DFinsupp.mapRange f hf 0 = 0

full_name: DFinsupp.zipWith
code: /-- Let `f i` be a binary operation `β₁ i → β₂ i → β i` such that `f i 0 0 = 0`.
Then `zipWith f hf` is a binary operation `Π₀ i, β₁ i → Π₀ i, β₂ i → Π₀ i, β i`. -/
def zipWith (f : ∀ i, β₁ i → β₂ i → β i) (hf : ∀ i, f i 0 0 = 0) (x : Π₀ i, β₁ i) (y : Π₀ i, β₂ i) :
    Π₀ i, β i 
goal: Π₀ (i : ι), β i

full_name: DFinsupp.zipWith_apply
code: @[simp]
theorem zipWith_apply (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 = f i (g₁ i) (g₂ i) 
goal: (DFinsupp.zipWith f hf g₁ g₂) i = f i (g₁ i) (g₂ i)

full_name: DFinsupp.piecewise
code: /-- `x.piecewise y s` is the finitely supported function equal to `x` on the set `s`,
  and to `y` on its complement. -/
def piecewise : Π₀ i, β i 
goal: Π₀ (i : ι), β i

full_name: DFinsupp.piecewise_apply
code: theorem piecewise_apply (i : ι) : x.piecewise y s i = if i ∈ s then x i else y i 
goal: (x.piecewise y s) i = if i ∈ s then x i else y i

full_name: DFinsupp.coe_piecewise
code: @[simp, norm_cast]
theorem coe_piecewise : ⇑(x.piecewise y s) = s.piecewise x y 
goal: ⇑(x.piecewise y s) = s.piecewise ⇑x ⇑y

full_name: DFinsupp.instAdd
code: instance [∀ i, AddZeroClass (β i)] : Add (Π₀ i, β i) 
goal: Add (Π₀ (i : ι), β i)

full_name: DFinsupp.add_apply
code: theorem add_apply [∀ i, AddZeroClass (β i)] (g₁ g₂ : Π₀ i, β i) (i : ι) :
    (g₁ + g₂) i = g₁ i + g₂ i 
goal: (g₁ + g₂) i = g₁ i + g₂ i

full_name: DFinsupp.coe_add
code: @[simp, norm_cast]
theorem coe_add [∀ i, AddZeroClass (β i)] (g₁ g₂ : Π₀ i, β i) : ⇑(g₁ + g₂) = g₁ + g₂ 
goal: ⇑(g₁ + g₂) = ⇑g₁ + ⇑g₂

full_name: DFinsupp.addZeroClass
code: instance addZeroClass [∀ i, AddZeroClass (β i)] : AddZeroClass (Π₀ i, β i) 
goal: AddZeroClass (Π₀ (i : ι), β i)

full_name: DFinsupp.instIsLeftCancelAdd
code: instance instIsLeftCancelAdd [∀ i, AddZeroClass (β i)] [∀ i, IsLeftCancelAdd (β i)] :
    IsLeftCancelAdd (Π₀ i, β i) 
goal: IsLeftCancelAdd (Π₀ (i : ι), β i)

full_name: DFinsupp.instIsRightCancelAdd
code: instance instIsRightCancelAdd [∀ i, AddZeroClass (β i)] [∀ i, IsRightCancelAdd (β i)] :
    IsRightCancelAdd (Π₀ i, β i) 
goal: IsRightCancelAdd (Π₀ (i : ι), β i)

full_name: DFinsupp.instIsCancelAdd
code: instance instIsCancelAdd [∀ i, AddZeroClass (β i)] [∀ i, IsCancelAdd (β i)] :
    IsCancelAdd (Π₀ i, β i) 
goal: IsCancelAdd (Π₀ (i : ι), β i)

full_name: DFinsupp.hasNatScalar
code: /-- Note the general `SMul` instance doesn't apply as `ℕ` is not distributive
unless `β i`'s addition is commutative. -/
instance hasNatScalar [∀ i, AddMonoid (β i)] : SMul ℕ (Π₀ i, β i) 
goal: SMul ℕ (Π₀ (i : ι), β i)

full_name: DFinsupp.nsmul_apply
code: theorem nsmul_apply [∀ i, AddMonoid (β i)] (b : ℕ) (v : Π₀ i, β i) (i : ι) : (b • v) i = b • v i 
goal: (b • v) i = b • v i

full_name: DFinsupp.coe_nsmul
code: @[simp, norm_cast]
theorem coe_nsmul [∀ i, AddMonoid (β i)] (b : ℕ) (v : Π₀ i, β i) : ⇑(b • v) = b • ⇑v 
goal: ⇑(b • v) = b • ⇑v

full_name: DFinsupp.instAddMonoid
code: instance [∀ i, AddMonoid (β i)] : AddMonoid (Π₀ i, β i) 
goal: AddMonoid (Π₀ (i : ι), β i)

full_name: DFinsupp.coeFnAddMonoidHom
code: /-- Coercion from a `DFinsupp` to a pi type is an `AddMonoidHom`. -/
def coeFnAddMonoidHom [∀ i, AddZeroClass (β i)] : (Π₀ i, β i) →+ ∀ i, β i 
goal: (Π₀ (i : ι), β i) →+ (i : ι) → β i

full_name: DFinsupp.evalAddMonoidHom
code: /-- Evaluation at a point is an `AddMonoidHom`. This is the finitely-supported version of
`Pi.evalAddMonoidHom`. -/
def evalAddMonoidHom [∀ i, AddZeroClass (β i)] (i : ι) : (Π₀ i, β i) →+ β i 
goal: (Π₀ (i : ι), β i) →+ β i

full_name: DFinsupp.addCommMonoid
code: instance addCommMonoid [∀ i, AddCommMonoid (β i)] : AddCommMonoid (Π₀ i, β i) 
goal: AddCommMonoid (Π₀ (i : ι), β i)

full_name: DFinsupp.coe_finset_sum
code: @[simp, norm_cast]
theorem coe_finset_sum {α} [∀ i, AddCommMonoid (β i)] (s : Finset α) (g : α → Π₀ i, β i) :
    ⇑(∑ a ∈ s, g a) = ∑ a ∈ s, ⇑(g a) 
goal: ⇑(∑ a ∈ s, g a) = ∑ a ∈ s, ⇑(g a)

full_name: DFinsupp.finset_sum_apply
code: @[simp]
theorem finset_sum_apply {α} [∀ i, AddCommMonoid (β i)] (s : Finset α) (g : α → Π₀ i, β i) (i : ι) :
    (∑ a ∈ s, g a) i = ∑ a ∈ s, g a i 
goal: (∑ a ∈ s, g a) i = ∑ a ∈ s, (g a) i

full_name: DFinsupp.instNeg
code: instance [∀ i, AddGroup (β i)] : Neg (Π₀ i, β i) 
goal: Neg (Π₀ (i : ι), β i)

full_name: DFinsupp.neg_apply
code: theorem neg_apply [∀ i, AddGroup (β i)] (g : Π₀ i, β i) (i : ι) : (-g) i = -g i 
goal: (-g) i = -g i

full_name: DFinsupp.coe_neg
code: @[simp, norm_cast] lemma coe_neg [∀ i, AddGroup (β i)] (g : Π₀ i, β i) : ⇑(-g) = -g 
goal: ⇑(-g) = -⇑g

full_name: DFinsupp.instSub
code: instance [∀ i, AddGroup (β i)] : Sub (Π₀ i, β i) 
goal: Sub (Π₀ (i : ι), β i)

full_name: DFinsupp.sub_apply
code: theorem sub_apply [∀ i, AddGroup (β i)] (g₁ g₂ : Π₀ i, β i) (i : ι) : (g₁ - g₂) i = g₁ i - g₂ i 
goal: (g₁ - g₂) i = g₁ i - g₂ i

full_name: DFinsupp.coe_sub
code: @[simp, norm_cast]
theorem coe_sub [∀ i, AddGroup (β i)] (g₁ g₂ : Π₀ i, β i) : ⇑(g₁ - g₂) = g₁ - g₂ 
goal: ⇑(g₁ - g₂) = ⇑g₁ - ⇑g₂

full_name: DFinsupp.hasIntScalar
code: /-- Note the general `SMul` instance doesn't apply as `ℤ` is not distributive
unless `β i`'s addition is commutative. -/
instance hasIntScalar [∀ i, AddGroup (β i)] : SMul ℤ (Π₀ i, β i) 
goal: SMul ℤ (Π₀ (i : ι), β i)

full_name: DFinsupp.zsmul_apply
code: theorem zsmul_apply [∀ i, AddGroup (β i)] (b : ℤ) (v : Π₀ i, β i) (i : ι) : (b • v) i = b • v i 
goal: (b • v) i = b • v i

full_name: DFinsupp.coe_zsmul
code: @[simp, norm_cast]
theorem coe_zsmul [∀ i, AddGroup (β i)] (b : ℤ) (v : Π₀ i, β i) : ⇑(b • v) = b • ⇑v 
goal: ⇑(b • v) = b • ⇑v

full_name: DFinsupp.instAddGroup
code: instance [∀ i, AddGroup (β i)] : AddGroup (Π₀ i, β i) 
goal: AddGroup (Π₀ (i : ι), β i)

full_name: DFinsupp.addCommGroup
code: instance addCommGroup [∀ i, AddCommGroup (β i)] : AddCommGroup (Π₀ i, β i) 
goal: AddCommGroup (Π₀ (i : ι), β i)

full_name: DFinsupp.instSMulOfDistribMulAction
code: /-- Dependent functions with finite support inherit a semiring action from an action on each
coordinate. -/
instance [Monoid γ] [∀ i, AddMonoid (β i)] [∀ i, DistribMulAction γ (β i)] : SMul γ (Π₀ i, β i) 
goal: SMul γ (Π₀ (i : ι), β i)

full_name: DFinsupp.smul_apply
code: theorem smul_apply [Monoid γ] [∀ i, AddMonoid (β i)] [∀ i, DistribMulAction γ (β i)] (b : γ)
    (v : Π₀ i, β i) (i : ι) : (b • v) i = b • v i 
goal: (b • v) i = b • v i

full_name: DFinsupp.coe_smul
code: @[simp, norm_cast]
theorem coe_smul [Monoid γ] [∀ i, AddMonoid (β i)] [∀ i, DistribMulAction γ (β i)] (b : γ)
    (v : Π₀ i, β i) : ⇑(b • v) = b • ⇑v 
goal: ⇑(b • v) = b • ⇑v

full_name: DFinsupp.smulCommClass
code: instance smulCommClass {δ : Type*} [Monoid γ] [Monoid δ] [∀ i, AddMonoid (β i)]
    [∀ i, DistribMulAction γ (β i)] [∀ i, DistribMulAction δ (β i)] [∀ i, SMulCommClass γ δ (β i)] :
    SMulCommClass γ δ (Π₀ i, β i) 
goal: SMulCommClass γ δ (Π₀ (i : ι), β i)

full_name: DFinsupp.isScalarTower
code: instance isScalarTower {δ : Type*} [Monoid γ] [Monoid δ] [∀ i, AddMonoid (β i)]
    [∀ i, DistribMulAction γ (β i)] [∀ i, DistribMulAction δ (β i)] [SMul γ δ]
    [∀ i, IsScalarTower γ δ (β i)] : IsScalarTower γ δ (Π₀ i, β i) 
goal: IsScalarTower γ δ (Π₀ (i : ι), β i)

full_name: DFinsupp.isCentralScalar
code: instance isCentralScalar [Monoid γ] [∀ i, AddMonoid (β i)] [∀ i, DistribMulAction γ (β i)]
    [∀ i, DistribMulAction γᵐᵒᵖ (β i)] [∀ i, IsCentralScalar γ (β i)] :
    IsCentralScalar γ (Π₀ i, β i) 
goal: IsCentralScalar γ (Π₀ (i : ι), β i)

full_name: DFinsupp.distribMulAction
code: /-- Dependent functions with finite support inherit a `DistribMulAction` structure from such a
structure on each coordinate. -/
instance distribMulAction [Monoid γ] [∀ i, AddMonoid (β i)] [∀ i, DistribMulAction γ (β i)] :
    DistribMulAction γ (Π₀ i, β i) 
goal: DistribMulAction γ (Π₀ (i : ι), β i)

full_name: DFinsupp.module
code: /-- Dependent functions with finite support inherit a module structure from such a structure on
each coordinate. -/
instance module [Semiring γ] [∀ i, AddCommMonoid (β i)] [∀ i, Module γ (β i)] :
    Module γ (Π₀ i, β i) 
goal: Module γ (Π₀ (i : ι), β i)

full_name: DFinsupp.filter
code: /-- `Filter p f` is the function which is `f i` if `p i` is true and 0 otherwise. -/
def filter [∀ i, Zero (β i)] (p : ι → Prop) [DecidablePred p] (x : Π₀ i, β i) : Π₀ i, β i 
goal: Π₀ (i : ι), β i

full_name: DFinsupp.filter_apply
code: @[simp]
theorem filter_apply [∀ i, Zero (β i)] (p : ι → Prop) [DecidablePred p] (i : ι) (f : Π₀ i, β i) :
    f.filter p i = if p i then f i else 0 
goal: (DFinsupp.filter p f) i = if p i then f i else 0

full_name: DFinsupp.filter_apply_pos
code: theorem filter_apply_pos [∀ i, Zero (β i)] {p : ι → Prop} [DecidablePred p] (f : Π₀ i, β i) {i : ι}
    (h : p i) : f.filter p i = f i 
goal: (DFinsupp.filter p f) i = f i

full_name: DFinsupp.filter_apply_neg
code: theorem filter_apply_neg [∀ i, Zero (β i)] {p : ι → Prop} [DecidablePred p] (f : Π₀ i, β i) {i : ι}
    (h : ¬p i) : f.filter p i = 0 
goal: (DFinsupp.filter p f) i = 0

full_name: DFinsupp.filter_pos_add_filter_neg
code: theorem filter_pos_add_filter_neg [∀ i, AddZeroClass (β i)] (f : Π₀ i, β i) (p : ι → Prop)
    [DecidablePred p] : (f.filter p + f.filter fun i => ¬p i) = f 
goal: DFinsupp.filter p f + DFinsupp.filter (fun i => ¬p i) f = f

full_name: DFinsupp.filter_zero
code: @[simp]
theorem filter_zero [∀ i, Zero (β i)] (p : ι → Prop) [DecidablePred p] :
    (0 : Π₀ i, β i).filter p = 0 
goal: DFinsupp.filter p 0 = 0

full_name: DFinsupp.filter_add
code: @[simp]
theorem filter_add [∀ i, AddZeroClass (β i)] (p : ι → Prop) [DecidablePred p] (f g : Π₀ i, β i) :
    (f + g).filter p = f.filter p + g.filter p 
goal: DFinsupp.filter p (f + g) = DFinsupp.filter p f + DFinsupp.filter p g

full_name: DFinsupp.filter_smul
code: @[simp]
theorem filter_smul [Monoid γ] [∀ i, AddMonoid (β i)] [∀ i, DistribMulAction γ (β i)] (p : ι → Prop)
    [DecidablePred p] (r : γ) (f : Π₀ i, β i) : (r • f).filter p = r • f.filter p 
goal: DFinsupp.filter p (r • f) = r • DFinsupp.filter p f

full_name: DFinsupp.filterAddMonoidHom
code: /-- `DFinsupp.filter` as an `AddMonoidHom`. -/
@[simps]
def filterAddMonoidHom [∀ i, AddZeroClass (β i)] (p : ι → Prop) [DecidablePred p] :
    (Π₀ i, β i) →+ Π₀ i, β i 
goal: (Π₀ (i : ι), β i) →+ Π₀ (i : ι), β i

full_name: DFinsupp.filterAddMonoidHom_apply
code: /-- `DFinsupp.filter` as an `AddMonoidHom`. -/
@[simps]
def filterAddMonoidHom [∀ i, AddZeroClass (β i)] (p : ι → Prop) [DecidablePred p] :
    (Π₀ i, β i) →+ Π₀ i, β i 
goal: (DFinsupp.filterAddMonoidHom β p) x = DFinsupp.filter p x

full_name: DFinsupp.filterLinearMap
code: /-- `DFinsupp.filter` as a `LinearMap`. -/
@[simps]
def filterLinearMap [Semiring γ] [∀ i, AddCommMonoid (β i)] [∀ i, Module γ (β i)] (p : ι → Prop)
    [DecidablePred p] : (Π₀ i, β i) →ₗ[γ] Π₀ i, β i 
goal: (Π₀ (i : ι), β i) →ₗ[γ] Π₀ (i : ι), β i

full_name: DFinsupp.filterLinearMap_apply
code: /-- `DFinsupp.filter` as a `LinearMap`. -/
@[simps]
def filterLinearMap [Semiring γ] [∀ i, AddCommMonoid (β i)] [∀ i, Module γ (β i)] (p : ι → Prop)
    [DecidablePred p] : (Π₀ i, β i) →ₗ[γ] Π₀ i, β i 
goal: (DFinsupp.filterLinearMap γ β p) x = DFinsupp.filter p x

full_name: DFinsupp.filter_neg
code: @[simp]
theorem filter_neg [∀ i, AddGroup (β i)] (p : ι → Prop) [DecidablePred p] (f : Π₀ i, β i) :
    (-f).filter p = -f.filter p 
goal: DFinsupp.filter p (-f) = -DFinsupp.filter p f

full_name: DFinsupp.filter_sub
code: @[simp]
theorem filter_sub [∀ i, AddGroup (β i)] (p : ι → Prop) [DecidablePred p] (f g : Π₀ i, β i) :
    (f - g).filter p = f.filter p - g.filter p 
goal: DFinsupp.filter p (f - g) = DFinsupp.filter p f - DFinsupp.filter p g

full_name: DFinsupp.subtypeDomain
code: /-- `subtypeDomain p f` is the restriction of the finitely supported function
  `f` to the subtype `p`. -/
def subtypeDomain [∀ i, Zero (β i)] (p : ι → Prop) [DecidablePred p] (x : Π₀ i, β i) :
    Π₀ i : Subtype p, β i 
goal: Π₀ (i : Subtype p), β ↑i

full_name: DFinsupp.subtypeDomain_zero
code: @[simp]
theorem subtypeDomain_zero [∀ i, Zero (β i)] {p : ι → Prop} [DecidablePred p] :
    subtypeDomain p (0 : Π₀ i, β i) = 0 
goal: DFinsupp.subtypeDomain p 0 = 0

full_name: DFinsupp.subtypeDomain_apply
code: @[simp]
theorem subtypeDomain_apply [∀ i, Zero (β i)] {p : ι → Prop} [DecidablePred p] {i : Subtype p}
    {v : Π₀ i, β i} : (subtypeDomain p v) i = v i 
goal: (DFinsupp.subtypeDomain p v) i = v ↑i

full_name: DFinsupp.subtypeDomain_add
code: @[simp]
theorem subtypeDomain_add [∀ i, AddZeroClass (β i)] {p : ι → Prop} [DecidablePred p]
    (v v' : Π₀ i, β i) : (v + v').subtypeDomain p = v.subtypeDomain p + v'.subtypeDomain p 
goal: DFinsupp.subtypeDomain p (v + v') = DFinsupp.subtypeDomain p v + DFinsupp.subtypeDomain p v'

full_name: DFinsupp.subtypeDomain_smul
code: @[simp]
theorem subtypeDomain_smul [Monoid γ] [∀ i, AddMonoid (β i)] [∀ i, DistribMulAction γ (β i)]
    {p : ι → Prop} [DecidablePred p] (r : γ) (f : Π₀ i, β i) :
    (r • f).subtypeDomain p = r • f.subtypeDomain p 
goal: DFinsupp.subtypeDomain p (r • f) = r • DFinsupp.subtypeDomain p f

full_name: DFinsupp.subtypeDomainAddMonoidHom
code: /-- `subtypeDomain` but as an `AddMonoidHom`. -/
@[simps]
def subtypeDomainAddMonoidHom [∀ i, AddZeroClass (β i)] (p : ι → Prop) [DecidablePred p] :
    (Π₀ i : ι, β i) →+ Π₀ i : Subtype p, β i 
goal: (Π₀ (i : ι), β i) →+ Π₀ (i : Subtype p), β ↑i

full_name: DFinsupp.subtypeDomainAddMonoidHom_apply
code: /-- `subtypeDomain` but as an `AddMonoidHom`. -/
@[simps]
def subtypeDomainAddMonoidHom [∀ i, AddZeroClass (β i)] (p : ι → Prop) [DecidablePred p] :
    (Π₀ i : ι, β i) →+ Π₀ i : Subtype p, β i 
goal: (DFinsupp.subtypeDomainAddMonoidHom β p) x = DFinsupp.subtypeDomain p x

full_name: DFinsupp.subtypeDomainLinearMap_apply
code: /-- `DFinsupp.subtypeDomain` as a `LinearMap`. -/
@[simps]
def subtypeDomainLinearMap [Semiring γ] [∀ i, AddCommMonoid (β i)] [∀ i, Module γ (β i)]
    (p : ι → Prop) [DecidablePred p] : (Π₀ i, β i) →ₗ[γ] Π₀ i : Subtype p, β i 
goal: (DFinsupp.subtypeDomainLinearMap γ β p) x = DFinsupp.subtypeDomain p x

full_name: DFinsupp.subtypeDomainLinearMap
code: /-- `DFinsupp.subtypeDomain` as a `LinearMap`. -/
@[simps]
def subtypeDomainLinearMap [Semiring γ] [∀ i, AddCommMonoid (β i)] [∀ i, Module γ (β i)]
    (p : ι → Prop) [DecidablePred p] : (Π₀ i, β i) →ₗ[γ] Π₀ i : Subtype p, β i 
goal: (Π₀ (i : ι), β i) →ₗ[γ] Π₀ (i : Subtype p), β ↑i

full_name: DFinsupp.subtypeDomain_neg
code: @[simp]
theorem subtypeDomain_neg [∀ i, AddGroup (β i)] {p : ι → Prop} [DecidablePred p] {v : Π₀ i, β i} :
    (-v).subtypeDomain p = -v.subtypeDomain p 
goal: DFinsupp.subtypeDomain p (-v) = -DFinsupp.subtypeDomain p v

full_name: DFinsupp.subtypeDomain_sub
code: @[simp]
theorem subtypeDomain_sub [∀ i, AddGroup (β i)] {p : ι → Prop} [DecidablePred p]
    {v v' : Π₀ i, β i} : (v - v').subtypeDomain p = v.subtypeDomain p - v'.subtypeDomain p 
goal: DFinsupp.subtypeDomain p (v - v') = DFinsupp.subtypeDomain p v - DFinsupp.subtypeDomain p v'

full_name: DFinsupp.finite_support
code: theorem finite_support (f : Π₀ i, β i) : Set.Finite { i | f i ≠ 0 } 
goal: {i | f i ≠ 0}.Finite

full_name: DFinsupp.mk
code: /-- Create an element of `Π₀ i, β i` from a finset `s` and a function `x`
defined on this `Finset`. -/
def mk (s : Finset ι) (x : ∀ i : (↑s : Set ι), β (i : ι)) : Π₀ i, β i 
goal: Π₀ (i : ι), β i

full_name: DFinsupp.mk_apply
code: @[simp]
theorem mk_apply : (mk s x : ∀ i, β i) i = if H : i ∈ s then x ⟨i, H⟩ else 0 
goal: (DFinsupp.mk s x) i = if H : i ∈ s then x ⟨i, H⟩ else 0

full_name: DFinsupp.mk_of_mem
code: theorem mk_of_mem (hi : i ∈ s) : (mk s x : ∀ i, β i) i = x ⟨i, hi⟩ 
goal: (DFinsupp.mk s x) i = x ⟨i, hi⟩

full_name: DFinsupp.mk_of_not_mem
code: theorem mk_of_not_mem (hi : i ∉ s) : (mk s x : ∀ i, β i) i = 0 
goal: (DFinsupp.mk s x) i = 0

full_name: DFinsupp.mk_injective
code: theorem mk_injective (s : Finset ι) : Function.Injective (@mk ι β _ _ s) 
goal: Function.Injective (DFinsupp.mk s)

full_name: DFinsupp.unique
code: instance unique [∀ i, Subsingleton (β i)] : Unique (Π₀ i, β i) 
goal: Unique (Π₀ (i : ι), β i)

full_name: DFinsupp.uniqueOfIsEmpty
code: instance uniqueOfIsEmpty [IsEmpty ι] : Unique (Π₀ i, β i) 
goal: Unique (Π₀ (i : ι), β i)

full_name: DFinsupp.equivFunOnFintype
code: /-- Given `Fintype ι`, `equivFunOnFintype` is the `Equiv` between `Π₀ i, β i` and `Π i, β i`.
  (All dependent functions on a finite type are finitely supported.) -/
@[simps apply]
def equivFunOnFintype [Fintype ι] : (Π₀ i, β i) ≃ ∀ i, β i 
goal: (Π₀ (i : ι), β i) ≃ ((i : ι) → β i)

full_name: DFinsupp.equivFunOnFintype_apply
code: /-- Given `Fintype ι`, `equivFunOnFintype` is the `Equiv` between `Π₀ i, β i` and `Π i, β i`.
  (All dependent functions on a finite type are finitely supported.) -/
@[simps apply]
def equivFunOnFintype [Fintype ι] : (Π₀ i, β i) ≃ ∀ i, β i 
goal: ∀ (a : Π₀ (i : ι), β i) (a_1 : ι), DFinsupp.equivFunOnFintype a a_1 = a a_1

full_name: DFinsupp.equivFunOnFintype_symm_coe
code: @[simp]
theorem equivFunOnFintype_symm_coe [Fintype ι] (f : Π₀ i, β i) : equivFunOnFintype.symm f = f 
goal: DFinsupp.equivFunOnFintype.symm ⇑f = f

full_name: DFinsupp.single
code: /-- The function `single i b : Π₀ i, β i` sends `i` to `b`
and all other points to `0`. -/
def single (i : ι) (b : β i) : Π₀ i, β i 
goal: Π₀ (i : ι), β i

full_name: DFinsupp.single_eq_pi_single
code: theorem single_eq_pi_single {i b} : ⇑(single i b : Π₀ i, β i) = Pi.single i b 
goal: ⇑(DFinsupp.single i b) = Pi.single i b

full_name: DFinsupp.single_apply
code: @[simp]
theorem single_apply {i i' b} :
    (single i b : Π₀ i, β i) i' = if h : i = i' then Eq.recOn h b else 0 
goal: (DFinsupp.single i b) i' = if h : i = i' then Eq.recOn h b else 0

full_name: DFinsupp.single_zero
code: @[simp]
theorem single_zero (i) : (single i 0 : Π₀ i, β i) = 0 
goal: DFinsupp.single i 0 = 0

full_name: DFinsupp.single_eq_same
code: theorem single_eq_same {i b} : (single i b : Π₀ i, β i) i = b 
goal: (DFinsupp.single i b) i = b

full_name: DFinsupp.single_eq_of_ne
code: theorem single_eq_of_ne {i i' b} (h : i ≠ i') : (single i b : Π₀ i, β i) i' = 0 
goal: (DFinsupp.single i b) i' = 0

full_name: DFinsupp.single_injective
code: theorem single_injective {i} : Function.Injective (single i : β i → Π₀ i, β i) 
goal: Function.Injective (DFinsupp.single i)

full_name: DFinsupp.single_eq_single_iff
code: /-- Like `Finsupp.single_eq_single_iff`, but with a `HEq` due to dependent types -/
theorem single_eq_single_iff (i j : ι) (xi : β i) (xj : β j) :
    DFinsupp.single i xi = DFinsupp.single j xj ↔ i = j ∧ HEq xi xj ∨ xi = 0 ∧ xj = 0 
goal: DFinsupp.single i xi = DFinsupp.single j xj ↔ i = j ∧ HEq xi xj ∨ xi = 0 ∧ xj = 0

full_name: DFinsupp.single_left_injective
code: /-- `DFinsupp.single a b` is injective in `a`. For the statement that it is injective in `b`, see
`DFinsupp.single_injective` -/
theorem single_left_injective {b : ∀ i : ι, β i} (h : ∀ i, b i ≠ 0) :
    Function.Injective (fun i => single i (b i) : ι → Π₀ i, β i) 
goal: Function.Injective fun i => DFinsupp.single i (b i)

full_name: DFinsupp.single_eq_zero
code: @[simp]
theorem single_eq_zero {i : ι} {xi : β i} : single i xi = 0 ↔ xi = 0 
goal: DFinsupp.single i xi = 0 ↔ xi = 0

full_name: DFinsupp.filter_single
code: theorem filter_single (p : ι → Prop) [DecidablePred p] (i : ι) (x : β i) :
    (single i x).filter p = if p i then single i x else 0 
goal: DFinsupp.filter p (DFinsupp.single i x) = if p i then DFinsupp.single i x else 0

full_name: DFinsupp.filter_single_pos
code: @[simp]
theorem filter_single_pos {p : ι → Prop} [DecidablePred p] (i : ι) (x : β i) (h : p i) :
    (single i x).filter p = single i x 
goal: DFinsupp.filter p (DFinsupp.single i x) = DFinsupp.single i x

full_name: DFinsupp.filter_single_neg
code: @[simp]
theorem filter_single_neg {p : ι → Prop} [DecidablePred p] (i : ι) (x : β i) (h : ¬p i) :
    (single i x).filter p = 0 
goal: DFinsupp.filter p (DFinsupp.single i x) = 0

full_name: DFinsupp.single_eq_of_sigma_eq
code: /-- Equality of sigma types is sufficient (but not necessary) to show equality of `DFinsupp`s. -/
theorem single_eq_of_sigma_eq {i j} {xi : β i} {xj : β j} (h : (⟨i, xi⟩ : Sigma β) = ⟨j, xj⟩) :
    DFinsupp.single i xi = DFinsupp.single j xj 
goal: DFinsupp.single i xi = DFinsupp.single j xj

full_name: DFinsupp.equivFunOnFintype_single
code: @[simp]
theorem equivFunOnFintype_single [Fintype ι] (i : ι) (m : β i) :
    (@DFinsupp.equivFunOnFintype ι β _ _) (DFinsupp.single i m) = Pi.single i m 
goal: DFinsupp.equivFunOnFintype (DFinsupp.single i m) = Pi.single i m

full_name: DFinsupp.equivFunOnFintype_symm_single
code: @[simp]
theorem equivFunOnFintype_symm_single [Fintype ι] (i : ι) (m : β i) :
    (@DFinsupp.equivFunOnFintype ι β _ _).symm (Pi.single i m) = DFinsupp.single i m 
goal: DFinsupp.equivFunOnFintype.symm (Pi.single i m) = DFinsupp.single i m

full_name: DFinsupp.zipWith_single_single
code: @[simp]
theorem zipWith_single_single (f : ∀ i, β₁ i → β₂ i → β i) (hf : ∀ i, f i 0 0 = 0)
    {i} (b₁ : β₁ i) (b₂ : β₂ i) :
    zipWith f hf (single i b₁) (single i b₂) = single i (f i b₁ b₂) 
goal: DFinsupp.zipWith f hf (DFinsupp.single i b₁) (DFinsupp.single i b₂) = DFinsupp.single i (f i b₁ b₂)

full_name: DFinsupp.erase
code: /-- Redefine `f i` to be `0`. -/
def erase (i : ι) (x : Π₀ i, β i) : Π₀ i, β i 
goal: Π₀ (i : ι), β i

full_name: DFinsupp.erase_apply
code: @[simp]
theorem erase_apply {i j : ι} {f : Π₀ i, β i} : (f.erase i) j = if j = i then 0 else f j 
goal: (DFinsupp.erase i f) j = if j = i then 0 else f j

full_name: DFinsupp.erase_same
code: theorem erase_same {i : ι} {f : Π₀ i, β i} : (f.erase i) i = 0 
goal: (DFinsupp.erase i f) i = 0

full_name: DFinsupp.erase_ne
code: theorem erase_ne {i i' : ι} {f : Π₀ i, β i} (h : i' ≠ i) : (f.erase i) i' = f i' 
goal: (DFinsupp.erase i f) i' = f i'

full_name: DFinsupp.piecewise_single_erase
code: theorem piecewise_single_erase (x : Π₀ i, β i) (i : ι)
    [∀ i' : ι, Decidable <| (i' ∈ ({i} : Set ι))] : -- Porting note: added Decidable hypothesis
    (single i (x i)).piecewise (x.erase i) {i} = x 
goal: (DFinsupp.single i (x i)).piecewise (DFinsupp.erase i x) {i} = x

full_name: DFinsupp.erase_eq_sub_single
code: theorem erase_eq_sub_single {β : ι → Type*} [∀ i, AddGroup (β i)] (f : Π₀ i, β i) (i : ι) :
    f.erase i = f - single i (f i) 
goal: DFinsupp.erase i f = f - DFinsupp.single i (f i)

full_name: DFinsupp.erase_zero
code: @[simp]
theorem erase_zero (i : ι) : erase i (0 : Π₀ i, β i) = 0 
goal: DFinsupp.erase i 0 = 0

full_name: DFinsupp.filter_ne_eq_erase
code: @[simp]
theorem filter_ne_eq_erase (f : Π₀ i, β i) (i : ι) : f.filter (· ≠ i) = f.erase i 
goal: DFinsupp.filter (fun x => x ≠ i) f = DFinsupp.erase i f

full_name: DFinsupp.filter_ne_eq_erase'
code: @[simp]
theorem filter_ne_eq_erase' (f : Π₀ i, β i) (i : ι) : f.filter (i ≠ ·) = f.erase i 
goal: DFinsupp.filter (fun x => i ≠ x) f = DFinsupp.erase i f

full_name: DFinsupp.erase_single
code: theorem erase_single (j : ι) (i : ι) (x : β i) :
    (single i x).erase j = if i = j then 0 else single i x 
goal: DFinsupp.erase j (DFinsupp.single i x) = if i = j then 0 else DFinsupp.single i x

full_name: DFinsupp.erase_single_same
code: @[simp]
theorem erase_single_same (i : ι) (x : β i) : (single i x).erase i = 0 
goal: DFinsupp.erase i (DFinsupp.single i x) = 0

full_name: DFinsupp.erase_single_ne
code: @[simp]
theorem erase_single_ne {i j : ι} (x : β i) (h : i ≠ j) : (single i x).erase j = single i x 
goal: DFinsupp.erase j (DFinsupp.single i x) = DFinsupp.single i x

full_name: DFinsupp.update
code: /-- Replace the value of a `Π₀ i, β i` at a given point `i : ι` by a given value `b : β i`.
If `b = 0`, this amounts to removing `i` from the support.
Otherwise, `i` is added to it.

This is the (dependent) finitely-supported version of `Function.update`. -/
def update : Π₀ i, β i 
goal: Π₀ (i : ι), β i

full_name: DFinsupp.coe_update
code: @[simp, norm_cast] lemma coe_update : (f.update i b : ∀ i : ι, β i) = Function.update f i b 
goal: ⇑(DFinsupp.update i f b) = Function.update (⇑f) i b

full_name: DFinsupp.update_self
code: @[simp]
theorem update_self : f.update i (f i) = f 
goal: DFinsupp.update i f (f i) = f

full_name: DFinsupp.update_eq_erase
code: @[simp]
theorem update_eq_erase : f.update i 0 = f.erase i 
goal: DFinsupp.update i f 0 = DFinsupp.erase i f

full_name: DFinsupp.update_eq_single_add_erase
code: theorem update_eq_single_add_erase {β : ι → Type*} [∀ i, AddZeroClass (β i)] (f : Π₀ i, β i)
    (i : ι) (b : β i) : f.update i b = single i b + f.erase i 
goal: DFinsupp.update i f b = DFinsupp.single i b + DFinsupp.erase i f

full_name: DFinsupp.update_eq_erase_add_single
code: theorem update_eq_erase_add_single {β : ι → Type*} [∀ i, AddZeroClass (β i)] (f : Π₀ i, β i)
    (i : ι) (b : β i) : f.update i b = f.erase i + single i b 
goal: DFinsupp.update i f b = DFinsupp.erase i f + DFinsupp.single i b

full_name: DFinsupp.update_eq_sub_add_single
code: theorem update_eq_sub_add_single {β : ι → Type*} [∀ i, AddGroup (β i)] (f : Π₀ i, β i) (i : ι)
    (b : β i) : f.update i b = f - single i (f i) + single i b 
goal: DFinsupp.update i f b = f - DFinsupp.single i (f i) + DFinsupp.single i b

full_name: DFinsupp.single_add
code: @[simp]
theorem single_add (i : ι) (b₁ b₂ : β i) : single i (b₁ + b₂) = single i b₁ + single i b₂ 
goal: DFinsupp.single i (b₁ + b₂) = DFinsupp.single i b₁ + DFinsupp.single i b₂

full_name: DFinsupp.erase_add
code: @[simp]
theorem erase_add (i : ι) (f₁ f₂ : Π₀ i, β i) : erase i (f₁ + f₂) = erase i f₁ + erase i f₂ 
goal: DFinsupp.erase i (f₁ + f₂) = DFinsupp.erase i f₁ + DFinsupp.erase i f₂

full_name: DFinsupp.singleAddHom
code: /-- `DFinsupp.single` as an `AddMonoidHom`. -/
@[simps]
def singleAddHom (i : ι) : β i →+ Π₀ i, β i 
goal: β i →+ Π₀ (i : ι), β i

full_name: DFinsupp.singleAddHom_apply
code: /-- `DFinsupp.single` as an `AddMonoidHom`. -/
@[simps]
def singleAddHom (i : ι) : β i →+ Π₀ i, β i 
goal: (DFinsupp.singleAddHom β i) b = DFinsupp.single i b

full_name: DFinsupp.eraseAddHom_apply
code: /-- `DFinsupp.erase` as an `AddMonoidHom`. -/
@[simps]
def eraseAddHom (i : ι) : (Π₀ i, β i) →+ Π₀ i, β i 
goal: (DFinsupp.eraseAddHom β i) x = DFinsupp.erase i x

full_name: DFinsupp.eraseAddHom
code: /-- `DFinsupp.erase` as an `AddMonoidHom`. -/
@[simps]
def eraseAddHom (i : ι) : (Π₀ i, β i) →+ Π₀ i, β i 
goal: (Π₀ (i : ι), β i) →+ Π₀ (i : ι), β i

full_name: DFinsupp.single_neg
code: @[simp]
theorem single_neg {β : ι → Type v} [∀ i, AddGroup (β i)] (i : ι) (x : β i) :
    single i (-x) = -single i x 
goal: DFinsupp.single i (-x) = -DFinsupp.single i x

full_name: DFinsupp.single_sub
code: @[simp]
theorem single_sub {β : ι → Type v} [∀ i, AddGroup (β i)] (i : ι) (x y : β i) :
    single i (x - y) = single i x - single i y 
goal: DFinsupp.single i (x - y) = DFinsupp.single i x - DFinsupp.single i y

full_name: DFinsupp.erase_neg
code: @[simp]
theorem erase_neg {β : ι → Type v} [∀ i, AddGroup (β i)] (i : ι) (f : Π₀ i, β i) :
    (-f).erase i = -f.erase i 
goal: DFinsupp.erase i (-f) = -DFinsupp.erase i f

full_name: DFinsupp.erase_sub
code: @[simp]
theorem erase_sub {β : ι → Type v} [∀ i, AddGroup (β i)] (i : ι) (f g : Π₀ i, β i) :
    (f - g).erase i = f.erase i - g.erase i 
goal: DFinsupp.erase i (f - g) = DFinsupp.erase i f - DFinsupp.erase i g

full_name: DFinsupp.single_add_erase
code: theorem single_add_erase (i : ι) (f : Π₀ i, β i) : single i (f i) + f.erase i = f 
goal: DFinsupp.single i (f i) + DFinsupp.erase i f = f

full_name: DFinsupp.erase_add_single
code: theorem erase_add_single (i : ι) (f : Π₀ i, β i) : f.erase i + single i (f i) = f 
goal: DFinsupp.erase i f + DFinsupp.single i (f i) = f

full_name: DFinsupp.induction
code: protected theorem induction {p : (Π₀ i, β i) → Prop} (f : Π₀ i, β i) (h0 : p 0)
    (ha : ∀ (i b) (f : Π₀ i, β i), f i = 0 → b ≠ 0 → p f → p (single i b + f)) : p f 
goal: p f

full_name: DFinsupp.induction₂
code: theorem induction₂ {p : (Π₀ i, β i) → Prop} (f : Π₀ i, β i) (h0 : p 0)
    (ha : ∀ (i b) (f : Π₀ i, β i), f i = 0 → b ≠ 0 → p f → p (f + single i b)) : p f 
goal: p f

full_name: DFinsupp.add_closure_iUnion_range_single
code: @[simp]
theorem add_closure_iUnion_range_single :
    AddSubmonoid.closure (⋃ i : ι, Set.range (single i : β i → Π₀ i, β i)) = ⊤ 
goal: AddSubmonoid.closure (⋃ i, Set.range (DFinsupp.single i)) = ⊤

full_name: DFinsupp.addHom_ext
code: /-- If two additive homomorphisms from `Π₀ i, β i` are equal on each `single a b`, then
they are equal. -/
theorem addHom_ext {γ : Type w} [AddZeroClass γ] ⦃f g : (Π₀ i, β i) →+ γ⦄
    (H : ∀ (i : ι) (y : β i), f (single i y) = g (single i y)) : f = g 
goal: f = g

full_name: DFinsupp.addHom_ext'
code: /-- If two additive homomorphisms from `Π₀ i, β i` are equal on each `single a b`, then
they are equal.

See note [partially-applied ext lemmas]. -/
@[ext]
theorem addHom_ext' {γ : Type w} [AddZeroClass γ] ⦃f g : (Π₀ i, β i) →+ γ⦄
    (H : ∀ x, f.comp (singleAddHom β x) = g.comp (singleAddHom β x)) : f = g 
goal: f = g

full_name: DFinsupp.mk_add
code: @[simp]
theorem mk_add [∀ i, AddZeroClass (β i)] {s : Finset ι} {x y : ∀ i : (↑s : Set ι), β i} :
    mk s (x + y) = mk s x + mk s y 
goal: DFinsupp.mk s (x + y) = DFinsupp.mk s x + DFinsupp.mk s y

full_name: DFinsupp.mk_zero
code: @[simp]
theorem mk_zero [∀ i, Zero (β i)] {s : Finset ι} : mk s (0 : ∀ i : (↑s : Set ι), β i.1) = 0 
goal: DFinsupp.mk s 0 = 0

full_name: DFinsupp.mk_neg
code: @[simp]
theorem mk_neg [∀ i, AddGroup (β i)] {s : Finset ι} {x : ∀ i : (↑s : Set ι), β i.1} :
    mk s (-x) = -mk s x 
goal: DFinsupp.mk s (-x) = -DFinsupp.mk s x

full_name: DFinsupp.mk_sub
code: @[simp]
theorem mk_sub [∀ i, AddGroup (β i)] {s : Finset ι} {x y : ∀ i : (↑s : Set ι), β i.1} :
    mk s (x - y) = mk s x - mk s y 
goal: DFinsupp.mk s (x - y) = DFinsupp.mk s x - DFinsupp.mk s y

full_name: DFinsupp.mkAddGroupHom
code: /-- If `s` is a subset of `ι` then `mk_addGroupHom s` is the canonical additive
group homomorphism from $\prod_{i\in s}\beta_i$ to $\prod_{\mathtt{i : \iota}}\beta_i.$-/
def mkAddGroupHom [∀ i, AddGroup (β i)] (s : Finset ι) :
    (∀ i : (s : Set ι), β ↑i) →+ Π₀ i : ι, β i 
goal: ((i : ↑↑s) → β ↑i) →+ Π₀ (i : ι), β i

full_name: DFinsupp.mk_smul
code: @[simp]
theorem mk_smul {s : Finset ι} (c : γ) (x : ∀ i : (↑s : Set ι), β (i : ι)) :
    mk s (c • x) = c • mk s x 
goal: DFinsupp.mk s (c • x) = c • DFinsupp.mk s x

full_name: DFinsupp.single_smul
code: @[simp]
theorem single_smul {i : ι} (c : γ) (x : β i) : single i (c • x) = c • single i x 
goal: DFinsupp.single i (c • x) = c • DFinsupp.single i x

full_name: DFinsupp.support
code: /-- Set `{i | f x ≠ 0}` as a `Finset`. -/
def support (f : Π₀ i, β i) : Finset ι 
goal: Finset ι

full_name: DFinsupp.support_mk_subset
code: @[simp]
theorem support_mk_subset {s : Finset ι} {x : ∀ i : (↑s : Set ι), β i.1} : (mk s x).support ⊆ s 
goal: (DFinsupp.mk s x).support ⊆ s

full_name: DFinsupp.support_mk'_subset
code: @[simp]
theorem support_mk'_subset {f : ∀ i, β i} {s : Multiset ι} {h} :
    (mk' f <| Trunc.mk ⟨s, h⟩).support ⊆ s.toFinset 
goal: { toFun := f, support' := Trunc.mk ⟨s, h⟩ }.support ⊆ s.toFinset

full_name: DFinsupp.mem_support_toFun
code: @[simp]
theorem mem_support_toFun (f : Π₀ i, β i) (i) : i ∈ f.support ↔ f i ≠ 0 
goal: i ∈ f.support ↔ f i ≠ 0

full_name: DFinsupp.eq_mk_support
code: theorem eq_mk_support (f : Π₀ i, β i) : f = mk f.support fun i => f i 
goal: f = DFinsupp.mk f.support fun i => f ↑i

full_name: DFinsupp.subtypeSupportEqEquiv_apply_coe
code: /-- Equivalence between dependent functions with finite support `s : Finset ι` and functions
`∀ i, {x : β i // x ≠ 0}`. -/
@[simps]
def subtypeSupportEqEquiv (s : Finset ι) :
    {f : Π₀ i, β i // f.support = s} ≃ ∀ i : s, {x : β i // x ≠ 0} 
goal: ∀ (x : { f // f.support = s }) (i : { x // x ∈ s }), ↑((DFinsupp.subtypeSupportEqEquiv s) x i) = ↑x ↑i

full_name: DFinsupp.subtypeSupportEqEquiv_symm_apply_coe
code: /-- Equivalence between dependent functions with finite support `s : Finset ι` and functions
`∀ i, {x : β i // x ≠ 0}`. -/
@[simps]
def subtypeSupportEqEquiv (s : Finset ι) :
    {f : Π₀ i, β i // f.support = s} ≃ ∀ i : s, {x : β i // x ≠ 0} 
goal: ↑((DFinsupp.subtypeSupportEqEquiv s).symm f) = DFinsupp.mk s fun i => ↑(f i)

full_name: DFinsupp.subtypeSupportEqEquiv
code: /-- Equivalence between dependent functions with finite support `s : Finset ι` and functions
`∀ i, {x : β i // x ≠ 0}`. -/
@[simps]
def subtypeSupportEqEquiv (s : Finset ι) :
    {f : Π₀ i, β i // f.support = s} ≃ ∀ i : s, {x : β i // x ≠ 0} 
goal: { f // f.support = s } ≃ ((i : { x // x ∈ s }) → { x // x ≠ 0 })

full_name: DFinsupp.sigmaFinsetFunEquiv
code: /-- Equivalence between all dependent finitely supported functions `f : Π₀ i, β i` and type
of pairs `⟨s : Finset ι, f : ∀ i : s, {x : β i // x ≠ 0}⟩`. -/
@[simps! apply_fst apply_snd_coe]
def sigmaFinsetFunEquiv : (Π₀ i, β i) ≃ Σ s : Finset ι, ∀ i : s, {x : β i // x ≠ 0} 
goal: (Π₀ (i : ι), β i) ≃ (s : Finset ι) × ((i : { x // x ∈ s }) → { x // x ≠ 0 })

full_name: DFinsupp.sigmaFinsetFunEquiv_apply_snd_coe
code: /-- Equivalence between all dependent finitely supported functions `f : Π₀ i, β i` and type
of pairs `⟨s : Finset ι, f : ∀ i : s, {x : β i // x ≠ 0}⟩`. -/
@[simps! apply_fst apply_snd_coe]
def sigmaFinsetFunEquiv : (Π₀ i, β i) ≃ Σ s : Finset ι, ∀ i : s, {x : β i // x ≠ 0} 
goal: ∀ (a : Π₀ (i : ι), β i) (i : { x // x ∈ ((Equiv.sigmaFiberEquiv DFinsupp.support).symm a).fst }),
  ↑((DFinsupp.sigmaFinsetFunEquiv a).snd i) = a ↑i

full_name: DFinsupp.sigmaFinsetFunEquiv_apply_fst
code: /-- Equivalence between all dependent finitely supported functions `f : Π₀ i, β i` and type
of pairs `⟨s : Finset ι, f : ∀ i : s, {x : β i // x ≠ 0}⟩`. -/
@[simps! apply_fst apply_snd_coe]
def sigmaFinsetFunEquiv : (Π₀ i, β i) ≃ Σ s : Finset ι, ∀ i : s, {x : β i // x ≠ 0} 
goal: ∀ (a : Π₀ (i : ι), β i), (DFinsupp.sigmaFinsetFunEquiv a).fst = a.support

full_name: DFinsupp.support_zero
code: @[simp]
theorem support_zero : (0 : Π₀ i, β i).support = ∅ 
goal: DFinsupp.support 0 = ∅

full_name: DFinsupp.mem_support_iff
code: theorem mem_support_iff {f : Π₀ i, β i} {i : ι} : i ∈ f.support ↔ f i ≠ 0 
goal: i ∈ f.support ↔ f i ≠ 0

full_name: DFinsupp.not_mem_support_iff
code: theorem not_mem_support_iff {f : Π₀ i, β i} {i : ι} : i ∉ f.support ↔ f i = 0 
goal: i ∉ f.support ↔ f i = 0

full_name: DFinsupp.support_eq_empty
code: @[simp]
theorem support_eq_empty {f : Π₀ i, β i} : f.support = ∅ ↔ f = 0 
goal: f.support = ∅ ↔ f = 0

full_name: DFinsupp.decidableZero
code: instance decidableZero [∀ (i) (x : β i), Decidable (x = 0)] (f : Π₀ i, β i) : Decidable (f = 0) 
goal: Decidable (f = 0)

full_name: DFinsupp.support_subset_iff
code: theorem support_subset_iff {s : Set ι} {f : Π₀ i, β i} : ↑f.support ⊆ s ↔ ∀ i ∉ s, f i = 0 
goal: ↑f.support ⊆ s ↔ ∀ i ∉ s, f i = 0

full_name: DFinsupp.support_single_ne_zero
code: theorem support_single_ne_zero {i : ι} {b : β i} (hb : b ≠ 0) : (single i b).support = {i} 
goal: (DFinsupp.single i b).support = {i}

full_name: DFinsupp.support_single_subset
code: theorem support_single_subset {i : ι} {b : β i} : (single i b).support ⊆ {i} 
goal: (DFinsupp.single i b).support ⊆ {i}

full_name: DFinsupp.mapRange_def
code: 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) 
goal: DFinsupp.mapRange f hf g = DFinsupp.mk g.support fun i => f (↑i) (g ↑i)

full_name: DFinsupp.mapRange_single
code: @[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) 
goal: DFinsupp.mapRange f hf (DFinsupp.single i b) = DFinsupp.single i (f i b)

full_name: DFinsupp.support_mapRange
code: theorem support_mapRange {f : ∀ i, β₁ i → β₂ i} {hf : ∀ i, f i 0 = 0} {g : Π₀ i, β₁ i} :
    (mapRange f hf g).support ⊆ g.support 
goal: (DFinsupp.mapRange f hf g).support ⊆ g.support

full_name: DFinsupp.zipWith_def
code: 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) 
goal: DFinsupp.zipWith f hf g₁ g₂ = DFinsupp.mk (g₁.support ∪ g₂.support) fun i => f (↑i) (g₁ ↑i) (g₂ ↑i)

full_name: DFinsupp.support_zipWith
code: 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 
goal: (DFinsupp.zipWith f hf g₁ g₂).support ⊆ g₁.support ∪ g₂.support

full_name: DFinsupp.erase_def
code: theorem erase_def (i : ι) (f : Π₀ i, β i) : f.erase i = mk (f.support.erase i) fun j => f j.1 
goal: DFinsupp.erase i f = DFinsupp.mk (f.support.erase i) fun j => f ↑j

full_name: DFinsupp.support_erase
code: @[simp]
theorem support_erase (i : ι) (f : Π₀ i, β i) : (f.erase i).support = f.support.erase i 
goal: (DFinsupp.erase i f).support = f.support.erase i

full_name: DFinsupp.support_update_ne_zero
code: theorem support_update_ne_zero (f : Π₀ i, β i) (i : ι) {b : β i} (h : b ≠ 0) :
    support (f.update i b) = insert i f.support 
goal: (DFinsupp.update i f b).support = insert i f.support

full_name: DFinsupp.support_update
code: theorem support_update (f : Π₀ i, β i) (i : ι) (b : β i) [Decidable (b = 0)] :
    support (f.update i b) = if b = 0 then support (f.erase i) else insert i f.support 
goal: (DFinsupp.update i f b).support = if b = 0 then (DFinsupp.erase i f).support else insert i f.support

full_name: DFinsupp.filter_def
code: theorem filter_def (f : Π₀ i, β i) : f.filter p = mk (f.support.filter p) fun i => f i.1 
goal: DFinsupp.filter p f = DFinsupp.mk (Finset.filter p f.support) fun i => f ↑i

full_name: DFinsupp.support_filter
code: @[simp]
theorem support_filter (f : Π₀ i, β i) : (f.filter p).support = f.support.filter p 
goal: (DFinsupp.filter p f).support = Finset.filter p f.support

full_name: DFinsupp.subtypeDomain_def
code: theorem subtypeDomain_def (f : Π₀ i, β i) :
    f.subtypeDomain p = mk (f.support.subtype p) fun i => f i 
goal: DFinsupp.subtypeDomain p f = DFinsupp.mk (Finset.subtype p f.support) fun i => f ↑↑i

full_name: DFinsupp.support_subtypeDomain
code: @[simp, nolint simpNF] -- Porting note: simpNF claims that LHS does not simplify, but it does
theorem support_subtypeDomain {f : Π₀ i, β i} :
    (subtypeDomain p f).support = f.support.subtype p 
goal: (DFinsupp.subtypeDomain p f).support = Finset.subtype p f.support

full_name: DFinsupp.support_add
code: theorem support_add [∀ i, AddZeroClass (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)]
    {g₁ g₂ : Π₀ i, β i} : (g₁ + g₂).support ⊆ g₁.support ∪ g₂.support 
goal: (g₁ + g₂).support ⊆ g₁.support ∪ g₂.support

full_name: DFinsupp.support_neg
code: @[simp]
theorem support_neg [∀ i, AddGroup (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)] {f : Π₀ i, β i} :
    support (-f) = support f 
goal: (-f).support = f.support

full_name: DFinsupp.support_smul
code: theorem support_smul {γ : Type w} [Semiring γ] [∀ i, AddCommMonoid (β i)] [∀ i, Module γ (β i)]
    [∀ (i : ι) (x : β i), Decidable (x ≠ 0)] (b : γ) (v : Π₀ i, β i) :
    (b • v).support ⊆ v.support 
goal: (b • v).support ⊆ v.support

full_name: DFinsupp.instDecidableEq
code: instance [∀ i, Zero (β i)] [∀ i, DecidableEq (β i)] : DecidableEq (Π₀ i, β i) 
goal: DecidableEq (Π₀ (i : ι), β i)

full_name: DFinsupp.comapDomain
code: /-- Reindexing (and possibly removing) terms of a dfinsupp. -/
noncomputable def comapDomain [∀ i, Zero (β i)] (h : κ → ι) (hh : Function.Injective h)
    (f : Π₀ i, β i) : Π₀ k, β (h k) 
goal: Π₀ (k : κ), β (h k)

full_name: DFinsupp.comapDomain_apply
code: @[simp]
theorem comapDomain_apply [∀ i, Zero (β i)] (h : κ → ι) (hh : Function.Injective h) (f : Π₀ i, β i)
    (k : κ) : comapDomain h hh f k = f (h k) 
goal: (DFinsupp.comapDomain h hh f) k = f (h k)

full_name: DFinsupp.comapDomain_zero
code: @[simp]
theorem comapDomain_zero [∀ i, Zero (β i)] (h : κ → ι) (hh : Function.Injective h) :
    comapDomain h hh (0 : Π₀ i, β i) = 0 
goal: DFinsupp.comapDomain h hh 0 = 0

full_name: DFinsupp.comapDomain_add
code: @[simp]
theorem comapDomain_add [∀ i, AddZeroClass (β i)] (h : κ → ι) (hh : Function.Injective h)
    (f g : Π₀ i, β i) : comapDomain h hh (f + g) = comapDomain h hh f + comapDomain h hh g 
goal: DFinsupp.comapDomain h hh (f + g) = DFinsupp.comapDomain h hh f + DFinsupp.comapDomain h hh g

full_name: DFinsupp.comapDomain_smul
code: @[simp]
theorem comapDomain_smul [Monoid γ] [∀ i, AddMonoid (β i)] [∀ i, DistribMulAction γ (β i)]
    (h : κ → ι) (hh : Function.Injective h) (r : γ) (f : Π₀ i, β i) :
    comapDomain h hh (r • f) = r • comapDomain h hh f 
goal: DFinsupp.comapDomain h hh (r • f) = r • DFinsupp.comapDomain h hh f

full_name: DFinsupp.comapDomain_single
code: @[simp]
theorem comapDomain_single [DecidableEq κ] [∀ i, Zero (β i)] (h : κ → ι) (hh : Function.Injective h)
    (k : κ) (x : β (h k)) : comapDomain h hh (single (h k) x) = single k x 
goal: DFinsupp.comapDomain h hh (DFinsupp.single (h k) x) = DFinsupp.single k x

full_name: DFinsupp.comapDomain'
code: /-- A computable version of comap_domain when an explicit left inverse is provided. -/
def comapDomain' [∀ i, Zero (β i)] (h : κ → ι) {h' : ι → κ} (hh' : Function.LeftInverse h' h)
    (f : Π₀ i, β i) : Π₀ k, β (h k) 
goal: Π₀ (k : κ), β (h k)

full_name: DFinsupp.comapDomain'_apply
code: @[simp]
theorem comapDomain'_apply [∀ i, Zero (β i)] (h : κ → ι) {h' : ι → κ}
    (hh' : Function.LeftInverse h' h) (f : Π₀ i, β i) (k : κ) : comapDomain' h hh' f k = f (h k) 
goal: (DFinsupp.comapDomain' h hh' f) k = f (h k)

full_name: DFinsupp.comapDomain'_zero
code: @[simp]
theorem comapDomain'_zero [∀ i, Zero (β i)] (h : κ → ι) {h' : ι → κ}
    (hh' : Function.LeftInverse h' h) : comapDomain' h hh' (0 : Π₀ i, β i) = 0 
goal: DFinsupp.comapDomain' h hh' 0 = 0

full_name: DFinsupp.comapDomain'_add
code: @[simp]
theorem comapDomain'_add [∀ i, AddZeroClass (β i)] (h : κ → ι) {h' : ι → κ}
    (hh' : Function.LeftInverse h' h) (f g : Π₀ i, β i) :
    comapDomain' h hh' (f + g) = comapDomain' h hh' f + comapDomain' h hh' g 
goal: DFinsupp.comapDomain' h hh' (f + g) = DFinsupp.comapDomain' h hh' f + DFinsupp.comapDomain' h hh' g

full_name: DFinsupp.comapDomain'_smul
code: @[simp]
theorem comapDomain'_smul [Monoid γ] [∀ i, AddMonoid (β i)] [∀ i, DistribMulAction γ (β i)]
    (h : κ → ι) {h' : ι → κ} (hh' : Function.LeftInverse h' h) (r : γ) (f : Π₀ i, β i) :
    comapDomain' h hh' (r • f) = r • comapDomain' h hh' f 
goal: DFinsupp.comapDomain' h hh' (r • f) = r • DFinsupp.comapDomain' h hh' f

full_name: DFinsupp.comapDomain'_single
code: @[simp]
theorem comapDomain'_single [DecidableEq ι] [DecidableEq κ] [∀ i, Zero (β i)] (h : κ → ι)
    {h' : ι → κ} (hh' : Function.LeftInverse h' h) (k : κ) (x : β (h k)) :
    comapDomain' h hh' (single (h k) x) = single k x 
goal: DFinsupp.comapDomain' h hh' (DFinsupp.single (h k) x) = DFinsupp.single k x

full_name: DFinsupp.equivCongrLeft
code: /-- Reindexing terms of a dfinsupp.

This is the dfinsupp version of `Equiv.piCongrLeft'`. -/
@[simps apply]
def equivCongrLeft [∀ i, Zero (β i)] (h : ι ≃ κ) : (Π₀ i, β i) ≃ Π₀ k, β (h.symm k) 
goal: (Π₀ (i : ι), β i) ≃ Π₀ (k : κ), β (h.symm k)

full_name: DFinsupp.equivCongrLeft_apply
code: /-- Reindexing terms of a dfinsupp.

This is the dfinsupp version of `Equiv.piCongrLeft'`. -/
@[simps apply]
def equivCongrLeft [∀ i, Zero (β i)] (h : ι ≃ κ) : (Π₀ i, β i) ≃ Π₀ k, β (h.symm k) 
goal: (DFinsupp.equivCongrLeft h) f = DFinsupp.comapDomain' ⇑h.symm ⋯ f

full_name: DFinsupp.hasAdd₂
code: instance hasAdd₂ [∀ i j, AddZeroClass (δ i j)] : Add (Π₀ (i : ι) (j : α i), δ i j) 
goal: Add (Π₀ (i : ι) (j : α i), δ i j)

full_name: DFinsupp.addZeroClass₂
code: instance addZeroClass₂ [∀ i j, AddZeroClass (δ i j)] : AddZeroClass (Π₀ (i : ι) (j : α i), δ i j) 
goal: AddZeroClass (Π₀ (i : ι) (j : α i), δ i j)

full_name: DFinsupp.addMonoid₂
code: instance addMonoid₂ [∀ i j, AddMonoid (δ i j)] : AddMonoid (Π₀ (i : ι) (j : α i), δ i j) 
goal: AddMonoid (Π₀ (i : ι) (j : α i), δ i j)

full_name: DFinsupp.distribMulAction₂
code: instance distribMulAction₂ [Monoid γ] [∀ i j, AddMonoid (δ i j)]
    [∀ i j, DistribMulAction γ (δ i j)] : DistribMulAction γ (Π₀ (i : ι) (j : α i), δ i j) 
goal: DistribMulAction γ (Π₀ (i : ι) (j : α i), δ i j)

full_name: DFinsupp.sigmaCurry
code: /-- The natural map between `Π₀ (i : Σ i, α i), δ i.1 i.2` and `Π₀ i (j : α i), δ i j`.  -/
def sigmaCurry [∀ i j, Zero (δ i j)] (f : Π₀ (i : Σ _, _), δ i.1 i.2) :
    Π₀ (i) (j), δ i j 
goal: Π₀ (i : ι) (j : α i), δ i j

full_name: DFinsupp.sigmaCurry_apply
code: @[simp]
theorem sigmaCurry_apply [∀ i j, Zero (δ i j)] (f : Π₀ (i : Σ _, _), δ i.1 i.2) (i : ι) (j : α i) :
    sigmaCurry f i j = f ⟨i, j⟩ 
goal: (f.sigmaCurry i) j = f ⟨i, j⟩

full_name: DFinsupp.sigmaCurry_zero
code: @[simp]
theorem sigmaCurry_zero [∀ i j, Zero (δ i j)] :
    sigmaCurry (0 : Π₀ (i : Σ _, _), δ i.1 i.2) = 0 
goal: DFinsupp.sigmaCurry 0 = 0

full_name: DFinsupp.sigmaCurry_add
code: @[simp]
theorem sigmaCurry_add [∀ i j, AddZeroClass (δ i j)] (f g : Π₀ (i : Σ _, _), δ i.1 i.2) :
    sigmaCurry (f + g) = sigmaCurry f + sigmaCurry g 
goal: (f + g).sigmaCurry = f.sigmaCurry + g.sigmaCurry

full_name: DFinsupp.sigmaCurry_smul
code: @[simp]
theorem sigmaCurry_smul [Monoid γ] [∀ i j, AddMonoid (δ i j)] [∀ i j, DistribMulAction γ (δ i j)]
    (r : γ) (f : Π₀ (i : Σ _, _), δ i.1 i.2) :
    sigmaCurry (r • f) = r • sigmaCurry f 
goal: (r • f).sigmaCurry = r • f.sigmaCurry

full_name: DFinsupp.sigmaCurry_single
code: @[simp]
theorem sigmaCurry_single [∀ i, DecidableEq (α i)] [∀ i j, Zero (δ i j)]
    (ij : Σ i, α i) (x : δ ij.1 ij.2) :
    sigmaCurry (single ij x) = single ij.1 (single ij.2 x : Π₀ j, δ ij.1 j) 
goal: (DFinsupp.single ij x).sigmaCurry = DFinsupp.single ij.fst (DFinsupp.single ij.snd x)

full_name: DFinsupp.sigmaUncurry
code: /-- The natural map between `Π₀ i (j : α i), δ i j` and `Π₀ (i : Σ i, α i), δ i.1 i.2`, inverse of
`curry`. -/
def sigmaUncurry [∀ i j, Zero (δ i j)] [DecidableEq ι] (f : Π₀ (i) (j), δ i j) :
    Π₀ i : Σi, _, δ i.1 i.2 
goal: Π₀ (i : (i : ι) × α i), δ i.fst i.snd

full_name: DFinsupp.sigmaUncurry_apply
code: @[simp]
theorem sigmaUncurry_apply [∀ i j, Zero (δ i j)] [DecidableEq ι]
    (f : Π₀ (i) (j), δ i j) (i : ι) (j : α i) :
    sigmaUncurry f ⟨i, j⟩ = f i j 
goal: f.sigmaUncurry ⟨i, j⟩ = (f i) j

full_name: DFinsupp.sigmaUncurry_zero
code: @[simp]
theorem sigmaUncurry_zero [∀ i j, Zero (δ i j)] [DecidableEq ι] :
    sigmaUncurry (0 : Π₀ (i) (j), δ i j) = 0 
goal: DFinsupp.sigmaUncurry 0 = 0

full_name: DFinsupp.sigmaUncurry_add
code: @[simp]
theorem sigmaUncurry_add [∀ i j, AddZeroClass (δ i j)] [DecidableEq ι]
    (f g : Π₀ (i) (j), δ i j) :
    sigmaUncurry (f + g) = sigmaUncurry f + sigmaUncurry g 
goal: (f + g).sigmaUncurry = f.sigmaUncurry + g.sigmaUncurry

full_name: DFinsupp.sigmaUncurry_smul
code: @[simp]
theorem sigmaUncurry_smul [Monoid γ] [∀ i j, AddMonoid (δ i j)] [DecidableEq ι]
    [∀ i j, DistribMulAction γ (δ i j)]
    (r : γ) (f : Π₀ (i) (j), δ i j) : sigmaUncurry (r • f) = r • sigmaUncurry f 
goal: (r • f).sigmaUncurry = r • f.sigmaUncurry

full_name: DFinsupp.sigmaUncurry_single
code: @[simp]
theorem sigmaUncurry_single [∀ i j, Zero (δ i j)] [DecidableEq ι] [∀ i, DecidableEq (α i)]
    (i) (j : α i) (x : δ i j) :
    sigmaUncurry (single i (single j x : Π₀ j : α i, δ i j)) = single ⟨i, j⟩ (by exact x) 
goal: (DFinsupp.single i (DFinsupp.single j x)).sigmaUncurry = DFinsupp.single ⟨i, j⟩ x

full_name: DFinsupp.sigmaCurryEquiv
code: /-- The natural bijection between `Π₀ (i : Σ i, α i), δ i.1 i.2` and `Π₀ i (j : α i), δ i j`.

This is the dfinsupp version of `Equiv.piCurry`. -/
def sigmaCurryEquiv [∀ i j, Zero (δ i j)] [DecidableEq ι] :
    (Π₀ i : Σi, _, δ i.1 i.2) ≃ Π₀ (i) (j), δ i j 
goal: (Π₀ (i : (i : ι) × α i), δ i.fst i.snd) ≃ Π₀ (i : ι) (j : α i), δ i j

full_name: DFinsupp.extendWith
code: /-- Adds a term to a dfinsupp, making a dfinsupp indexed by an `Option`.

This is the dfinsupp version of `Option.rec`. -/
def extendWith [∀ i, Zero (α i)] (a : α none) (f : Π₀ i, α (some i)) : Π₀ i, α i 
goal: Π₀ (i : Option ι), α i

full_name: DFinsupp.extendWith_none
code: @[simp]
theorem extendWith_none [∀ i, Zero (α i)] (f : Π₀ i, α (some i)) (a : α none) :
    f.extendWith a none = a 
goal: (DFinsupp.extendWith a f) none = a

full_name: DFinsupp.extendWith_some
code: @[simp]
theorem extendWith_some [∀ i, Zero (α i)] (f : Π₀ i, α (some i)) (a : α none) (i : ι) :
    f.extendWith a (some i) = f i 
goal: (DFinsupp.extendWith a f) (some i) = f i

full_name: DFinsupp.extendWith_single_zero
code: @[simp]
theorem extendWith_single_zero [DecidableEq ι] [∀ i, Zero (α i)] (i : ι) (x : α (some i)) :
    (single i x).extendWith 0 = single (some i) x 
goal: DFinsupp.extendWith 0 (DFinsupp.single i x) = DFinsupp.single (some i) x

full_name: DFinsupp.extendWith_zero
code: @[simp]
theorem extendWith_zero [DecidableEq ι] [∀ i, Zero (α i)] (x : α none) :
    (0 : Π₀ i, α (some i)).extendWith x = single none x 
goal: DFinsupp.extendWith x 0 = DFinsupp.single none x

full_name: DFinsupp.equivProdDFinsupp_apply
code: /-- Bijection obtained by separating the term of index `none` of a dfinsupp over `Option ι`.

This is the dfinsupp version of `Equiv.piOptionEquivProd`. -/
@[simps]
noncomputable def equivProdDFinsupp [∀ i, Zero (α i)] :
    (Π₀ i, α i) ≃ α none × Π₀ i, α (some i) 
goal: DFinsupp.equivProdDFinsupp f = (f none, DFinsupp.comapDomain some ⋯ f)

full_name: DFinsupp.equivProdDFinsupp
code: /-- Bijection obtained by separating the term of index `none` of a dfinsupp over `Option ι`.

This is the dfinsupp version of `Equiv.piOptionEquivProd`. -/
@[simps]
noncomputable def equivProdDFinsupp [∀ i, Zero (α i)] :
    (Π₀ i, α i) ≃ α none × Π₀ i, α (some i) 
goal: (Π₀ (i : Option ι), α i) ≃ α none × Π₀ (i : ι), α (some i)

full_name: DFinsupp.equivProdDFinsupp_symm_apply
code: /-- Bijection obtained by separating the term of index `none` of a dfinsupp over `Option ι`.

This is the dfinsupp version of `Equiv.piOptionEquivProd`. -/
@[simps]
noncomputable def equivProdDFinsupp [∀ i, Zero (α i)] :
    (Π₀ i, α i) ≃ α none × Π₀ i, α (some i) 
goal: DFinsupp.equivProdDFinsupp.symm f = DFinsupp.extendWith f.1 f.2

full_name: DFinsupp.equivProdDFinsupp_add
code: theorem equivProdDFinsupp_add [∀ i, AddZeroClass (α i)] (f g : Π₀ i, α i) :
    equivProdDFinsupp (f + g) = equivProdDFinsupp f + equivProdDFinsupp g 
goal: DFinsupp.equivProdDFinsupp (f + g) = DFinsupp.equivProdDFinsupp f + DFinsupp.equivProdDFinsupp g

full_name: DFinsupp.equivProdDFinsupp_smul
code: theorem equivProdDFinsupp_smul [Monoid γ] [∀ i, AddMonoid (α i)] [∀ i, DistribMulAction γ (α i)]
    (r : γ) (f : Π₀ i, α i) : equivProdDFinsupp (r • f) = r • equivProdDFinsupp f 
goal: DFinsupp.equivProdDFinsupp (r • f) = r • DFinsupp.equivProdDFinsupp f

full_name: DFinsupp.sum
code: /-- `DFinsupp.prod f g` is the product of `g i (f i)` over the support of `f`. -/
@[to_additive "`sum f g` is the sum of `g i (f i)` over the support of `f`."]
def prod [∀ i, Zero (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)] [CommMonoid γ] (f : Π₀ i, β i)
    (g : ∀ i, β i → γ) : γ 
goal: γ

full_name: DFinsupp.prod
code: /-- `DFinsupp.prod f g` is the product of `g i (f i)` over the support of `f`. -/
@[to_additive "`sum f g` is the sum of `g i (f i)` over the support of `f`."]
def prod [∀ i, Zero (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)] [CommMonoid γ] (f : Π₀ i, β i)
    (g : ∀ i, β i → γ) : γ 
goal: γ

full_name: map_dfinsupp_prod
code: @[to_additive (attr := simp)]
theorem _root_.map_dfinsupp_prod
    {R S H : Type*} [∀ i, Zero (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)]
    [CommMonoid R] [CommMonoid S] [FunLike H R S] [MonoidHomClass H R S] (h : H) (f : Π₀ i, β i)
    (g : ∀ i, β i → R) : h (f.prod g) = f.prod fun a b => h (g a b) 
goal: h (f.prod g) = f.prod fun a b => h (g a b)

full_name: map_dfinsupp_sum
code: @[to_additive (attr := simp)]
theorem _root_.map_dfinsupp_prod
    {R S H : Type*} [∀ i, Zero (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)]
    [CommMonoid R] [CommMonoid S] [FunLike H R S] [MonoidHomClass H R S] (h : H) (f : Π₀ i, β i)
    (g : ∀ i, β i → R) : h (f.prod g) = f.prod fun a b => h (g a b) 
goal: h (f.sum g) = f.sum fun a b => h (g a b)

full_name: DFinsupp.prod_mapRange_index
code: @[to_additive]
theorem prod_mapRange_index {β₁ : ι → Type v₁} {β₂ : ι → Type v₂} [∀ i, Zero (β₁ i)]
    [∀ i, Zero (β₂ i)] [∀ (i) (x : β₁ i), Decidable (x ≠ 0)] [∀ (i) (x : β₂ i), Decidable (x ≠ 0)]
    [CommMonoid γ] {f : ∀ i, β₁ i → β₂ i} {hf : ∀ i, f i 0 = 0} {g : Π₀ i, β₁ i} {h : ∀ i, β₂ i → γ}
    (h0 : ∀ i, h i 0 = 1) : (mapRange f hf g).prod h = g.prod fun i b => h i (f i b) 
goal: (DFinsupp.mapRange f hf g).prod h = g.prod fun i b => h i (f i b)

full_name: DFinsupp.sum_mapRange_index
code: @[to_additive]
theorem prod_mapRange_index {β₁ : ι → Type v₁} {β₂ : ι → Type v₂} [∀ i, Zero (β₁ i)]
    [∀ i, Zero (β₂ i)] [∀ (i) (x : β₁ i), Decidable (x ≠ 0)] [∀ (i) (x : β₂ i), Decidable (x ≠ 0)]
    [CommMonoid γ] {f : ∀ i, β₁ i → β₂ i} {hf : ∀ i, f i 0 = 0} {g : Π₀ i, β₁ i} {h : ∀ i, β₂ i → γ}
    (h0 : ∀ i, h i 0 = 1) : (mapRange f hf g).prod h = g.prod fun i b => h i (f i b) 
goal: (DFinsupp.mapRange f hf g).sum h = g.sum fun i b => h i (f i b)

full_name: DFinsupp.prod_zero_index
code: @[to_additive]
theorem prod_zero_index [∀ i, AddCommMonoid (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)]
    [CommMonoid γ] {h : ∀ i, β i → γ} : (0 : Π₀ i, β i).prod h = 1 
goal: DFinsupp.prod 0 h = 1

full_name: DFinsupp.sum_zero_index
code: @[to_additive]
theorem prod_zero_index [∀ i, AddCommMonoid (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)]
    [CommMonoid γ] {h : ∀ i, β i → γ} : (0 : Π₀ i, β i).prod h = 1 
goal: DFinsupp.sum 0 h = 0

full_name: DFinsupp.prod_single_index
code: @[to_additive]
theorem prod_single_index [∀ i, Zero (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)] [CommMonoid γ]
    {i : ι} {b : β i} {h : ∀ i, β i → γ} (h_zero : h i 0 = 1) : (single i b).prod h = h i b 
goal: (DFinsupp.single i b).prod h = h i b

full_name: DFinsupp.sum_single_index
code: @[to_additive]
theorem prod_single_index [∀ i, Zero (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)] [CommMonoid γ]
    {i : ι} {b : β i} {h : ∀ i, β i → γ} (h_zero : h i 0 = 1) : (single i b).prod h = h i b 
goal: (DFinsupp.single i b).sum h = h i b

full_name: DFinsupp.prod_neg_index
code: @[to_additive]
theorem prod_neg_index [∀ i, AddGroup (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)] [CommMonoid γ]
    {g : Π₀ i, β i} {h : ∀ i, β i → γ} (h0 : ∀ i, h i 0 = 1) :
    (-g).prod h = g.prod fun i b => h i (-b) 
goal: (-g).prod h = g.prod fun i b => h i (-b)

full_name: DFinsupp.sum_neg_index
code: @[to_additive]
theorem prod_neg_index [∀ i, AddGroup (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)] [CommMonoid γ]
    {g : Π₀ i, β i} {h : ∀ i, β i → γ} (h0 : ∀ i, h i 0 = 1) :
    (-g).prod h = g.prod fun i b => h i (-b) 
goal: (-g).sum h = g.sum fun i b => h i (-b)

full_name: DFinsupp.sum_comm
code: @[to_additive]
theorem prod_comm {ι₁ ι₂ : Sort _} {β₁ : ι₁ → Type*} {β₂ : ι₂ → Type*} [DecidableEq ι₁]
    [DecidableEq ι₂] [∀ i, Zero (β₁ i)] [∀ i, Zero (β₂ i)] [∀ (i) (x : β₁ i), Decidable (x ≠ 0)]
    [∀ (i) (x : β₂ i), Decidable (x ≠ 0)] [CommMonoid γ] (f₁ : Π₀ i, β₁ i) (f₂ : Π₀ i, β₂ i)
    (h : ∀ i, β₁ i → ∀ i, β₂ i → γ) :
    (f₁.prod fun i₁ x₁ => f₂.prod fun i₂ x₂ => h i₁ x₁ i₂ x₂) =
      f₂.prod fun i₂ x₂ => f₁.prod fun i₁ x₁ => h i₁ x₁ i₂ x₂ 
goal: (f₁.sum fun i₁ x₁ => f₂.sum fun i₂ x₂ => h i₁ x₁ i₂ x₂) = f₂.sum fun i₂ x₂ => f₁.sum fun i₁ x₁ => h i₁ x₁ i₂ x₂

full_name: DFinsupp.prod_comm
code: @[to_additive]
theorem prod_comm {ι₁ ι₂ : Sort _} {β₁ : ι₁ → Type*} {β₂ : ι₂ → Type*} [DecidableEq ι₁]
    [DecidableEq ι₂] [∀ i, Zero (β₁ i)] [∀ i, Zero (β₂ i)] [∀ (i) (x : β₁ i), Decidable (x ≠ 0)]
    [∀ (i) (x : β₂ i), Decidable (x ≠ 0)] [CommMonoid γ] (f₁ : Π₀ i, β₁ i) (f₂ : Π₀ i, β₂ i)
    (h : ∀ i, β₁ i → ∀ i, β₂ i → γ) :
    (f₁.prod fun i₁ x₁ => f₂.prod fun i₂ x₂ => h i₁ x₁ i₂ x₂) =
      f₂.prod fun i₂ x₂ => f₁.prod fun i₁ x₁ => h i₁ x₁ i₂ x₂ 
goal: (f₁.prod fun i₁ x₁ => f₂.prod fun i₂ x₂ => h i₁ x₁ i₂ x₂) = f₂.prod fun i₂ x₂ => f₁.prod fun i₁ x₁ => h i₁ x₁ i₂ x₂

full_name: DFinsupp.sum_apply
code: @[simp]
theorem sum_apply {ι₁ : Type u₁} [DecidableEq ι₁] {β₁ : ι₁ → Type v₁} [∀ i₁, Zero (β₁ i₁)]
    [∀ (i) (x : β₁ i), Decidable (x ≠ 0)] [∀ i, AddCommMonoid (β i)] {f : Π₀ i₁, β₁ i₁}
    {g : ∀ i₁, β₁ i₁ → Π₀ i, β i} {i₂ : ι} : (f.sum g) i₂ = f.sum fun i₁ b => g i₁ b i₂ 
goal: (f.sum g) i₂ = f.sum fun i₁ b => (g i₁ b) i₂

full_name: DFinsupp.support_sum
code: theorem support_sum {ι₁ : Type u₁} [DecidableEq ι₁] {β₁ : ι₁ → Type v₁} [∀ i₁, Zero (β₁ i₁)]
    [∀ (i) (x : β₁ i), Decidable (x ≠ 0)] [∀ i, AddCommMonoid (β i)]
    [∀ (i) (x : β i), Decidable (x ≠ 0)] {f : Π₀ i₁, β₁ i₁} {g : ∀ i₁, β₁ i₁ → Π₀ i, β i} :
    (f.sum g).support ⊆ f.support.biUnion fun i => (g i (f i)).support 
goal: (f.sum g).support ⊆ f.support.biUnion fun i => (g i (f i)).support

full_name: DFinsupp.sum_zero
code: @[to_additive (attr := simp)]
theorem prod_one [∀ i, AddCommMonoid (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)] [CommMonoid γ]
    {f : Π₀ i, β i} : (f.prod fun _ _ => (1 : γ)) = 1 
goal: (f.sum fun x x => 0) = 0

full_name: DFinsupp.prod_one
code: @[to_additive (attr := simp)]
theorem prod_one [∀ i, AddCommMonoid (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)] [CommMonoid γ]
    {f : Π₀ i, β i} : (f.prod fun _ _ => (1 : γ)) = 1 
goal: (f.prod fun x x => 1) = 1

full_name: DFinsupp.sum_add
code: @[to_additive (attr := simp)]
theorem prod_mul [∀ i, AddCommMonoid (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)] [CommMonoid γ]
    {f : Π₀ i, β i} {h₁ h₂ : ∀ i, β i → γ} :
    (f.prod fun i b => h₁ i b * h₂ i b) = f.prod h₁ * f.prod h₂ 
goal: (f.sum fun i b => h₁ i b + h₂ i b) = f.sum h₁ + f.sum h₂

full_name: DFinsupp.prod_mul
code: @[to_additive (attr := simp)]
theorem prod_mul [∀ i, AddCommMonoid (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)] [CommMonoid γ]
    {f : Π₀ i, β i} {h₁ h₂ : ∀ i, β i → γ} :
    (f.prod fun i b => h₁ i b * h₂ i b) = f.prod h₁ * f.prod h₂ 
goal: (f.prod fun i b => h₁ i b * h₂ i b) = f.prod h₁ * f.prod h₂

full_name: DFinsupp.sum_neg
code: @[to_additive (attr := simp)]
theorem prod_inv [∀ i, AddCommMonoid (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)] [CommGroup γ]
    {f : Π₀ i, β i} {h : ∀ i, β i → γ} : (f.prod fun i b => (h i b)⁻¹) = (f.prod h)⁻¹ 
goal: (f.sum fun i b => -h i b) = -f.sum h

full_name: DFinsupp.prod_inv
code: @[to_additive (attr := simp)]
theorem prod_inv [∀ i, AddCommMonoid (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)] [CommGroup γ]
    {f : Π₀ i, β i} {h : ∀ i, β i → γ} : (f.prod fun i b => (h i b)⁻¹) = (f.prod h)⁻¹ 
goal: (f.prod fun i b => (h i b)⁻¹) = (f.prod h)⁻¹

full_name: DFinsupp.prod_eq_one
code: @[to_additive]
theorem prod_eq_one [∀ i, Zero (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)] [CommMonoid γ]
    {f : Π₀ i, β i} {h : ∀ i, β i → γ} (hyp : ∀ i, h i (f i) = 1) : f.prod h = 1 
goal: f.prod h = 1

full_name: DFinsupp.sum_eq_zero
code: @[to_additive]
theorem prod_eq_one [∀ i, Zero (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)] [CommMonoid γ]
    {f : Π₀ i, β i} {h : ∀ i, β i → γ} (hyp : ∀ i, h i (f i) = 1) : f.prod h = 1 
goal: f.sum h = 0

full_name: DFinsupp.smul_sum
code: theorem smul_sum {α : Type*} [Monoid α] [∀ i, Zero (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)]
    [AddCommMonoid γ] [DistribMulAction α γ] {f : Π₀ i, β i} {h : ∀ i, β i → γ} {c : α} :
    c • f.sum h = f.sum fun a b => c • h a b 
goal: c • f.sum h = f.sum fun a b => c • h a b

full_name: DFinsupp.prod_add_index
code: @[to_additive]
theorem prod_add_index [∀ i, AddCommMonoid (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)]
    [CommMonoid γ] {f g : Π₀ i, β i} {h : ∀ i, β i → γ} (h_zero : ∀ i, h i 0 = 1)
    (h_add : ∀ i b₁ b₂, h i (b₁ + b₂) = h i b₁ * h i b₂) : (f + g).prod h = f.prod h * g.prod h 
goal: (f + g).prod h = f.prod h * g.prod h

full_name: DFinsupp.sum_add_index
code: @[to_additive]
theorem prod_add_index [∀ i, AddCommMonoid (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)]
    [CommMonoid γ] {f g : Π₀ i, β i} {h : ∀ i, β i → γ} (h_zero : ∀ i, h i 0 = 1)
    (h_add : ∀ i b₁ b₂, h i (b₁ + b₂) = h i b₁ * h i b₂) : (f + g).prod h = f.prod h * g.prod h 
goal: (f + g).sum h = f.sum h + g.sum h

full_name: dfinsupp_sum_mem
code: @[to_additive]
theorem _root_.dfinsupp_prod_mem [∀ i, Zero (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)]
    [CommMonoid γ] {S : Type*} [SetLike S γ] [SubmonoidClass S γ]
    (s : S) (f : Π₀ i, β i) (g : ∀ i, β i → γ)
    (h : ∀ c, f c ≠ 0 → g c (f c) ∈ s) : f.prod g ∈ s 
goal: f.sum g ∈ s

full_name: dfinsupp_prod_mem
code: @[to_additive]
theorem _root_.dfinsupp_prod_mem [∀ i, Zero (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)]
    [CommMonoid γ] {S : Type*} [SetLike S γ] [SubmonoidClass S γ]
    (s : S) (f : Π₀ i, β i) (g : ∀ i, β i → γ)
    (h : ∀ c, f c ≠ 0 → g c (f c) ∈ s) : f.prod g ∈ s 
goal: f.prod g ∈ s

full_name: DFinsupp.prod_eq_prod_fintype
code: @[to_additive (attr := simp)]
theorem prod_eq_prod_fintype [Fintype ι] [∀ i, Zero (β i)] [∀ (i : ι) (x : β i), Decidable (x ≠ 0)]
    -- Porting note: `f` was a typeclass argument
    [CommMonoid γ] (v : Π₀ i, β i) {f : ∀ i, β i → γ} (hf : ∀ i, f i 0 = 1) :
    v.prod f = ∏ i, f i (DFinsupp.equivFunOnFintype v i) 
goal: v.prod f = ∏ i : ι, f i (DFinsupp.equivFunOnFintype v i)

full_name: DFinsupp.sum_eq_sum_fintype
code: @[to_additive (attr := simp)]
theorem prod_eq_prod_fintype [Fintype ι] [∀ i, Zero (β i)] [∀ (i : ι) (x : β i), Decidable (x ≠ 0)]
    -- Porting note: `f` was a typeclass argument
    [CommMonoid γ] (v : Π₀ i, β i) {f : ∀ i, β i → γ} (hf : ∀ i, f i 0 = 1) :
    v.prod f = ∏ i, f i (DFinsupp.equivFunOnFintype v i) 
goal: v.sum f = ∑ i : ι, f i (DFinsupp.equivFunOnFintype v i)

full_name: DFinsupp.prod_eq_zero_iff
code: @[simp]
lemma prod_eq_zero_iff : f.prod g = 0 ↔ ∃ i ∈ f.support, g i (f i) = 0 
goal: f.prod g = 0 ↔ ∃ i ∈ f.support, g i (f i) = 0

full_name: DFinsupp.prod_ne_zero_iff
code: lemma prod_ne_zero_iff : f.prod g ≠ 0 ↔ ∀ i ∈ f.support, g i (f i) ≠ 0 
goal: f.prod g ≠ 0 ↔ ∀ i ∈ f.support, g i (f i) ≠ 0

full_name: DFinsupp.sumAddHom
code: /--
When summing over an `AddMonoidHom`, the decidability assumption is not needed, and the result is
also an `AddMonoidHom`.
-/
def sumAddHom [∀ i, AddZeroClass (β i)] [AddCommMonoid γ] (φ : ∀ i, β i →+ γ) :
    (Π₀ i, β i) →+ γ 
goal: (Π₀ (i : ι), β i) →+ γ

full_name: DFinsupp.sumAddHom_single
code: @[simp]
theorem sumAddHom_single [∀ i, AddZeroClass (β i)] [AddCommMonoid γ] (φ : ∀ i, β i →+ γ) (i)
    (x : β i) : sumAddHom φ (single i x) = φ i x 
goal: (DFinsupp.sumAddHom φ) (DFinsupp.single i x) = (φ i) x

full_name: DFinsupp.sumAddHom_comp_single
code: @[simp]
theorem sumAddHom_comp_single [∀ i, AddZeroClass (β i)] [AddCommMonoid γ] (f : ∀ i, β i →+ γ)
    (i : ι) : (sumAddHom f).comp (singleAddHom β i) = f i 
goal: (DFinsupp.sumAddHom f).comp (DFinsupp.singleAddHom β i) = f i

full_name: DFinsupp.sumAddHom_apply
code: /-- While we didn't need decidable instances to define it, we do to reduce it to a sum -/
theorem sumAddHom_apply [∀ i, AddZeroClass (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)]
    [AddCommMonoid γ] (φ : ∀ i, β i →+ γ) (f : Π₀ i, β i) : sumAddHom φ f = f.sum fun x => φ x 
goal: (DFinsupp.sumAddHom φ) f = f.sum fun x => ⇑(φ x)

full_name: dfinsupp_sumAddHom_mem
code: theorem _root_.dfinsupp_sumAddHom_mem [∀ i, AddZeroClass (β i)] [AddCommMonoid γ] {S : Type*}
    [SetLike S γ] [AddSubmonoidClass S γ] (s : S) (f : Π₀ i, β i) (g : ∀ i, β i →+ γ)
    (h : ∀ c, f c ≠ 0 → g c (f c) ∈ s) : DFinsupp.sumAddHom g f ∈ s 
goal: (DFinsupp.sumAddHom g) f ∈ s

full_name: AddSubmonoid.iSup_eq_mrange_dfinsupp_sumAddHom
code: /-- The supremum of a family of commutative additive submonoids is equal to the range of
`DFinsupp.sumAddHom`; that is, every element in the `iSup` can be produced from taking a finite
number of non-zero elements of `S i`, coercing them to `γ`, and summing them. -/
theorem _root_.AddSubmonoid.iSup_eq_mrange_dfinsupp_sumAddHom
    [AddCommMonoid γ] (S : ι → AddSubmonoid γ) :
    iSup S = AddMonoidHom.mrange (DFinsupp.sumAddHom fun i => (S i).subtype) 
goal: iSup S = AddMonoidHom.mrange (DFinsupp.sumAddHom fun i => (S i).subtype)

full_name: AddSubmonoid.bsupr_eq_mrange_dfinsupp_sumAddHom
code: /-- The bounded supremum of a family of commutative additive submonoids is equal to the range of
`DFinsupp.sumAddHom` composed with `DFinsupp.filterAddMonoidHom`; that is, every element in the
bounded `iSup` can be produced from taking a finite number of non-zero elements from the `S i` that
satisfy `p i`, coercing them to `γ`, and summing them. -/
theorem _root_.AddSubmonoid.bsupr_eq_mrange_dfinsupp_sumAddHom (p : ι → Prop) [DecidablePred p]
    [AddCommMonoid γ] (S : ι → AddSubmonoid γ) :
    ⨆ (i) (_ : p i), S i =
      AddMonoidHom.mrange ((sumAddHom fun i => (S i).subtype).comp (filterAddMonoidHom _ p)) 
goal: ⨆ i, ⨆ (_ : p i), S i =
  AddMonoidHom.mrange
    ((DFinsupp.sumAddHom fun i => (S i).subtype).comp (DFinsupp.filterAddMonoidHom (fun i => ↥(S i)) p))

full_name: AddSubmonoid.mem_iSup_iff_exists_dfinsupp
code: theorem _root_.AddSubmonoid.mem_iSup_iff_exists_dfinsupp [AddCommMonoid γ] (S : ι → AddSubmonoid γ)
    (x : γ) : x ∈ iSup S ↔ ∃ f : Π₀ i, S i, DFinsupp.sumAddHom (fun i => (S i).subtype) f = x 
goal: x ∈ iSup S ↔ ∃ f, (DFinsupp.sumAddHom fun i => (S i).subtype) f = x

full_name: AddSubmonoid.mem_iSup_iff_exists_dfinsupp'
code: /-- A variant of `AddSubmonoid.mem_iSup_iff_exists_dfinsupp` with the RHS fully unfolded. -/
theorem _root_.AddSubmonoid.mem_iSup_iff_exists_dfinsupp' [AddCommMonoid γ] (S : ι → AddSubmonoid γ)
    [∀ (i) (x : S i), Decidable (x ≠ 0)] (x : γ) :
    x ∈ iSup S ↔ ∃ f : Π₀ i, S i, (f.sum fun i xi => ↑xi) = x 
goal: x ∈ iSup S ↔ ∃ f, (f.sum fun i xi => ↑xi) = x

full_name: AddSubmonoid.mem_bsupr_iff_exists_dfinsupp
code: theorem _root_.AddSubmonoid.mem_bsupr_iff_exists_dfinsupp (p : ι → Prop) [DecidablePred p]
    [AddCommMonoid γ] (S : ι → AddSubmonoid γ) (x : γ) :
    (x ∈ ⨆ (i) (_ : p i), S i) ↔
      ∃ f : Π₀ i, S i, DFinsupp.sumAddHom (fun i => (S i).subtype) (f.filter p) = x 
goal: x ∈ ⨆ i, ⨆ (_ : p i), S i ↔ ∃ f, (DFinsupp.sumAddHom fun i => (S i).subtype) (DFinsupp.filter p f) = x

full_name: DFinsupp.sumAddHom_comm
code: theorem sumAddHom_comm {ι₁ ι₂ : Sort _} {β₁ : ι₁ → Type*} {β₂ : ι₂ → Type*} {γ : Type*}
    [DecidableEq ι₁] [DecidableEq ι₂] [∀ i, AddZeroClass (β₁ i)] [∀ i, AddZeroClass (β₂ i)]
    [AddCommMonoid γ] (f₁ : Π₀ i, β₁ i) (f₂ : Π₀ i, β₂ i) (h : ∀ i j, β₁ i →+ β₂ j →+ γ) :
    sumAddHom (fun i₂ => sumAddHom (fun i₁ => h i₁ i₂) f₁) f₂ =
      sumAddHom (fun i₁ => sumAddHom (fun i₂ => (h i₁ i₂).flip) f₂) f₁ 
goal: (DFinsupp.sumAddHom fun i₂ => (DFinsupp.sumAddHom fun i₁ => h i₁ i₂) f₁) f₂ =
  (DFinsupp.sumAddHom fun i₁ => (DFinsupp.sumAddHom fun i₂ => (h i₁ i₂).flip) f₂) f₁

full_name: DFinsupp.liftAddHom
code: /-- The `DFinsupp` version of `Finsupp.liftAddHom`,-/
@[simps apply symm_apply]
def liftAddHom [∀ i, AddZeroClass (β i)] [AddCommMonoid γ] :
    (∀ i, β i →+ γ) ≃+ ((Π₀ i, β i) →+ γ) 
goal: ((i : ι) → β i →+ γ) ≃+ ((Π₀ (i : ι), β i) →+ γ)

full_name: DFinsupp.liftAddHom_apply
code: /-- The `DFinsupp` version of `Finsupp.liftAddHom`,-/
@[simps apply symm_apply]
def liftAddHom [∀ i, AddZeroClass (β i)] [AddCommMonoid γ] :
    (∀ i, β i →+ γ) ≃+ ((Π₀ i, β i) →+ γ) 
goal: DFinsupp.liftAddHom φ = DFinsupp.sumAddHom φ

full_name: DFinsupp.liftAddHom_symm_apply
code: /-- The `DFinsupp` version of `Finsupp.liftAddHom`,-/
@[simps apply symm_apply]
def liftAddHom [∀ i, AddZeroClass (β i)] [AddCommMonoid γ] :
    (∀ i, β i →+ γ) ≃+ ((Π₀ i, β i) →+ γ) 
goal: DFinsupp.liftAddHom.symm F i = F.comp (DFinsupp.singleAddHom β i)

full_name: DFinsupp.liftAddHom_singleAddHom
code: /-- The `DFinsupp` version of `Finsupp.liftAddHom_singleAddHom`,-/
@[simp, nolint simpNF] -- Porting note: linter claims that simp can prove this, but it can not
theorem liftAddHom_singleAddHom [∀ i, AddCommMonoid (β i)] :
    liftAddHom (β := β) (singleAddHom β) = AddMonoidHom.id (Π₀ i, β i) 
goal: DFinsupp.liftAddHom (DFinsupp.singleAddHom β) = AddMonoidHom.id (Π₀ (i : ι), β i)

full_name: DFinsupp.liftAddHom_apply_single
code: /-- The `DFinsupp` version of `Finsupp.liftAddHom_apply_single`,-/
theorem liftAddHom_apply_single [∀ i, AddZeroClass (β i)] [AddCommMonoid γ] (f : ∀ i, β i →+ γ)
    (i : ι) (x : β i) : liftAddHom (β := β) f (single i x) = f i x 
goal: (DFinsupp.liftAddHom f) (DFinsupp.single i x) = (f i) x

full_name: DFinsupp.liftAddHom_comp_single
code: /-- The `DFinsupp` version of `Finsupp.liftAddHom_comp_single`,-/
theorem liftAddHom_comp_single [∀ i, AddZeroClass (β i)] [AddCommMonoid γ] (f : ∀ i, β i →+ γ)
    (i : ι) : (liftAddHom (β := β) f).comp (singleAddHom β i) = f i 
goal: (DFinsupp.liftAddHom f).comp (DFinsupp.singleAddHom β i) = f i

full_name: DFinsupp.comp_liftAddHom
code: /-- The `DFinsupp` version of `Finsupp.comp_liftAddHom`,-/
theorem comp_liftAddHom {δ : Type*} [∀ i, AddZeroClass (β i)] [AddCommMonoid γ] [AddCommMonoid δ]
    (g : γ →+ δ) (f : ∀ i, β i →+ γ) :
    g.comp (liftAddHom (β := β) f) = liftAddHom (β := β) fun a => g.comp (f a) 
goal: g.comp (DFinsupp.liftAddHom f) = DFinsupp.liftAddHom fun a => g.comp (f a)

full_name: DFinsupp.sumAddHom_zero
code: @[simp]
theorem sumAddHom_zero [∀ i, AddZeroClass (β i)] [AddCommMonoid γ] :
    (sumAddHom fun i => (0 : β i →+ γ)) = 0 
goal: (DFinsupp.sumAddHom fun i => 0) = 0

full_name: DFinsupp.sumAddHom_add
code: @[simp]
theorem sumAddHom_add [∀ i, AddZeroClass (β i)] [AddCommMonoid γ] (g : ∀ i, β i →+ γ)
    (h : ∀ i, β i →+ γ) : (sumAddHom fun i => g i + h i) = sumAddHom g + sumAddHom h 
goal: (DFinsupp.sumAddHom fun i => g i + h i) = DFinsupp.sumAddHom g + DFinsupp.sumAddHom h

full_name: DFinsupp.sumAddHom_singleAddHom
code: @[simp]
theorem sumAddHom_singleAddHom [∀ i, AddCommMonoid (β i)] :
    sumAddHom (singleAddHom β) = AddMonoidHom.id _ 
goal: DFinsupp.sumAddHom (DFinsupp.singleAddHom β) = AddMonoidHom.id (Π₀ (i : ι), β i)

full_name: DFinsupp.comp_sumAddHom
code: theorem comp_sumAddHom {δ : Type*} [∀ i, AddZeroClass (β i)] [AddCommMonoid γ] [AddCommMonoid δ]
    (g : γ →+ δ) (f : ∀ i, β i →+ γ) : g.comp (sumAddHom f) = sumAddHom fun a => g.comp (f a) 
goal: g.comp (DFinsupp.sumAddHom f) = DFinsupp.sumAddHom fun a => g.comp (f a)

full_name: DFinsupp.sum_sub_index
code: theorem sum_sub_index [∀ i, AddGroup (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)] [AddCommGroup γ]
    {f g : Π₀ i, β i} {h : ∀ i, β i → γ} (h_sub : ∀ i b₁ b₂, h i (b₁ - b₂) = h i b₁ - h i b₂) :
    (f - g).sum h = f.sum h - g.sum h 
goal: (f - g).sum h = f.sum h - g.sum h

full_name: DFinsupp.sum_finset_sum_index
code: @[to_additive]
theorem prod_finset_sum_index {γ : Type w} {α : Type x} [∀ i, AddCommMonoid (β i)]
    [∀ (i) (x : β i), Decidable (x ≠ 0)] [CommMonoid γ] {s : Finset α} {g : α → Π₀ i, β i}
    {h : ∀ i, β i → γ} (h_zero : ∀ i, h i 0 = 1)
    (h_add : ∀ i b₁ b₂, h i (b₁ + b₂) = h i b₁ * h i b₂) :
    (∏ i ∈ s, (g i).prod h) = (∑ i ∈ s, g i).prod h 
goal: ∑ i ∈ s, (g i).sum h = (∑ i ∈ s, g i).sum h

full_name: DFinsupp.prod_finset_sum_index
code: @[to_additive]
theorem prod_finset_sum_index {γ : Type w} {α : Type x} [∀ i, AddCommMonoid (β i)]
    [∀ (i) (x : β i), Decidable (x ≠ 0)] [CommMonoid γ] {s : Finset α} {g : α → Π₀ i, β i}
    {h : ∀ i, β i → γ} (h_zero : ∀ i, h i 0 = 1)
    (h_add : ∀ i b₁ b₂, h i (b₁ + b₂) = h i b₁ * h i b₂) :
    (∏ i ∈ s, (g i).prod h) = (∑ i ∈ s, g i).prod h 
goal: ∏ i ∈ s, (g i).prod h = (∑ i ∈ s, g i).prod h

full_name: DFinsupp.sum_sum_index
code: @[to_additive]
theorem prod_sum_index {ι₁ : Type u₁} [DecidableEq ι₁] {β₁ : ι₁ → Type v₁} [∀ i₁, Zero (β₁ i₁)]
    [∀ (i) (x : β₁ i), Decidable (x ≠ 0)] [∀ i, AddCommMonoid (β i)]
    [∀ (i) (x : β i), Decidable (x ≠ 0)] [CommMonoid γ] {f : Π₀ i₁, β₁ i₁}
    {g : ∀ i₁, β₁ i₁ → Π₀ i, β i} {h : ∀ i, β i → γ} (h_zero : ∀ i, h i 0 = 1)
    (h_add : ∀ i b₁ b₂, h i (b₁ + b₂) = h i b₁ * h i b₂) :
    (f.sum g).prod h = f.prod fun i b => (g i b).prod h 
goal: (f.sum g).sum h = f.sum fun i b => (g i b).sum h

full_name: DFinsupp.prod_sum_index
code: @[to_additive]
theorem prod_sum_index {ι₁ : Type u₁} [DecidableEq ι₁] {β₁ : ι₁ → Type v₁} [∀ i₁, Zero (β₁ i₁)]
    [∀ (i) (x : β₁ i), Decidable (x ≠ 0)] [∀ i, AddCommMonoid (β i)]
    [∀ (i) (x : β i), Decidable (x ≠ 0)] [CommMonoid γ] {f : Π₀ i₁, β₁ i₁}
    {g : ∀ i₁, β₁ i₁ → Π₀ i, β i} {h : ∀ i, β i → γ} (h_zero : ∀ i, h i 0 = 1)
    (h_add : ∀ i b₁ b₂, h i (b₁ + b₂) = h i b₁ * h i b₂) :
    (f.sum g).prod h = f.prod fun i b => (g i b).prod h 
goal: (f.sum g).prod h = f.prod fun i b => (g i b).prod h

full_name: DFinsupp.sum_single
code: @[simp]
theorem sum_single [∀ i, AddCommMonoid (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)] {f : Π₀ i, β i} :
    f.sum single = f 
goal: f.sum DFinsupp.single = f

full_name: DFinsupp.prod_subtypeDomain_index
code: @[to_additive]
theorem prod_subtypeDomain_index [∀ i, Zero (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)]
    [CommMonoid γ] {v : Π₀ i, β i} {p : ι → Prop} [DecidablePred p] {h : ∀ i, β i → γ}
    (hp : ∀ x ∈ v.support, p x) : (v.subtypeDomain p).prod (fun i b => h i b) = v.prod h 
goal: ((DFinsupp.subtypeDomain p v).prod fun i b => h (↑i) b) = v.prod h

full_name: DFinsupp.sum_subtypeDomain_index
code: @[to_additive]
theorem prod_subtypeDomain_index [∀ i, Zero (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)]
    [CommMonoid γ] {v : Π₀ i, β i} {p : ι → Prop} [DecidablePred p] {h : ∀ i, β i → γ}
    (hp : ∀ x ∈ v.support, p x) : (v.subtypeDomain p).prod (fun i b => h i b) = v.prod h 
goal: ((DFinsupp.subtypeDomain p v).sum fun i b => h (↑i) b) = v.sum h

full_name: DFinsupp.subtypeDomain_sum
code: theorem subtypeDomain_sum [∀ i, AddCommMonoid (β i)] {s : Finset γ} {h : γ → Π₀ i, β i}
    {p : ι → Prop} [DecidablePred p] :
    (∑ c ∈ s, h c).subtypeDomain p = ∑ c ∈ s, (h c).subtypeDomain p 
goal: DFinsupp.subtypeDomain p (∑ c ∈ s, h c) = ∑ c ∈ s, DFinsupp.subtypeDomain p (h c)

full_name: DFinsupp.subtypeDomain_finsupp_sum
code: theorem subtypeDomain_finsupp_sum {δ : γ → Type x} [DecidableEq γ] [∀ c, Zero (δ c)]
    [∀ (c) (x : δ c), Decidable (x ≠ 0)] [∀ i, AddCommMonoid (β i)] {p : ι → Prop} [DecidablePred p]
    {s : Π₀ c, δ c} {h : ∀ c, δ c → Π₀ i, β i} :
    (s.sum h).subtypeDomain p = s.sum fun c d => (h c d).subtypeDomain p 
goal: DFinsupp.subtypeDomain p (s.sum h) = s.sum fun c d => DFinsupp.subtypeDomain p (h c d)

full_name: DFinsupp.mapRange_add
code: theorem mapRange_add (f : ∀ i, β₁ i → β₂ i) (hf : ∀ i, f i 0 = 0)
    (hf' : ∀ i x y, f i (x + y) = f i x + f i y) (g₁ g₂ : Π₀ i, β₁ i) :
    mapRange f hf (g₁ + g₂) = mapRange f hf g₁ + mapRange f hf g₂ 
goal: DFinsupp.mapRange f hf (g₁ + g₂) = DFinsupp.mapRange f hf g₁ + DFinsupp.mapRange f hf g₂

full_name: DFinsupp.mapRange.addMonoidHom
code: /-- `DFinsupp.mapRange` as an `AddMonoidHom`. -/
@[simps apply]
def mapRange.addMonoidHom (f : ∀ i, β₁ i →+ β₂ i) : (Π₀ i, β₁ i) →+ Π₀ i, β₂ i 
goal: (Π₀ (i : ι), β₁ i) →+ Π₀ (i : ι), β₂ i

full_name: DFinsupp.mapRange.addMonoidHom_apply
code: /-- `DFinsupp.mapRange` as an `AddMonoidHom`. -/
@[simps apply]
def mapRange.addMonoidHom (f : ∀ i, β₁ i →+ β₂ i) : (Π₀ i, β₁ i) →+ Π₀ i, β₂ i 
goal: (DFinsupp.mapRange.addMonoidHom f) x = DFinsupp.mapRange (fun i x => (f i) x) ⋯ x

full_name: DFinsupp.mapRange.addMonoidHom_id
code: @[simp]
theorem mapRange.addMonoidHom_id :
    (mapRange.addMonoidHom fun i => AddMonoidHom.id (β₂ i)) = AddMonoidHom.id _ 
goal: (DFinsupp.mapRange.addMonoidHom fun i => AddMonoidHom.id (β₂ i)) = AddMonoidHom.id (Π₀ (i : ι), β₂ i)

full_name: DFinsupp.mapRange.addMonoidHom_comp
code: theorem mapRange.addMonoidHom_comp (f : ∀ i, β₁ i →+ β₂ i) (f₂ : ∀ i, β i →+ β₁ i) :
    (mapRange.addMonoidHom fun i => (f i).comp (f₂ i)) =
      (mapRange.addMonoidHom f).comp (mapRange.addMonoidHom f₂) 
goal: (DFinsupp.mapRange.addMonoidHom fun i => (f i).comp (f₂ i)) =
  (DFinsupp.mapRange.addMonoidHom f).comp (DFinsupp.mapRange.addMonoidHom f₂)

full_name: DFinsupp.mapRange.addEquiv_apply
code: /-- `DFinsupp.mapRange.addMonoidHom` as an `AddEquiv`. -/
@[simps apply]
def mapRange.addEquiv (e : ∀ i, β₁ i ≃+ β₂ i) : (Π₀ i, β₁ i) ≃+ Π₀ i, β₂ i 
goal: (DFinsupp.mapRange.addEquiv e) x = DFinsupp.mapRange (fun i x => (e i) x) ⋯ x

full_name: DFinsupp.mapRange.addEquiv
code: /-- `DFinsupp.mapRange.addMonoidHom` as an `AddEquiv`. -/
@[simps apply]
def mapRange.addEquiv (e : ∀ i, β₁ i ≃+ β₂ i) : (Π₀ i, β₁ i) ≃+ Π₀ i, β₂ i 
goal: (Π₀ (i : ι), β₁ i) ≃+ Π₀ (i : ι), β₂ i

full_name: DFinsupp.mapRange.addEquiv_refl
code: @[simp]
theorem mapRange.addEquiv_refl :
    (mapRange.addEquiv fun i => AddEquiv.refl (β₁ i)) = AddEquiv.refl _ 
goal: (DFinsupp.mapRange.addEquiv fun i => AddEquiv.refl (β₁ i)) = AddEquiv.refl (Π₀ (i : ι), β₁ i)

full_name: DFinsupp.mapRange.addEquiv_trans
code: theorem mapRange.addEquiv_trans (f : ∀ i, β i ≃+ β₁ i) (f₂ : ∀ i, β₁ i ≃+ β₂ i) :
    (mapRange.addEquiv fun i => (f i).trans (f₂ i)) =
      (mapRange.addEquiv f).trans (mapRange.addEquiv f₂) 
goal: (DFinsupp.mapRange.addEquiv fun i => (f i).trans (f₂ i)) =
  (DFinsupp.mapRange.addEquiv f).trans (DFinsupp.mapRange.addEquiv f₂)

full_name: DFinsupp.mapRange.addEquiv_symm
code: @[simp]
theorem mapRange.addEquiv_symm (e : ∀ i, β₁ i ≃+ β₂ i) :
    (mapRange.addEquiv e).symm = mapRange.addEquiv fun i => (e i).symm 
goal: (DFinsupp.mapRange.addEquiv e).symm = DFinsupp.mapRange.addEquiv fun i => (e i).symm

full_name: AddMonoidHom.coe_dfinsupp_sum
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_dfinsupp_prod [Monoid R] [CommMonoid S] (f : Π₀ i, β i) (g : ∀ i, β i → R →* S) :
    ⇑(f.prod g) = f.prod fun a b => ⇑(g a b) 
goal: ⇑(f.sum g) = f.sum fun a b => ⇑(g a b)

full_name: MonoidHom.coe_dfinsupp_prod
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_dfinsupp_prod [Monoid R] [CommMonoid S] (f : Π₀ i, β i) (g : ∀ i, β i → R →* S) :
    ⇑(f.prod g) = f.prod fun a b => ⇑(g a b) 
goal: ⇑(f.prod g) = f.prod fun a b => ⇑(g a b)

full_name: AddMonoidHom.dfinsupp_sum_apply
code: @[to_additive]
theorem dfinsupp_prod_apply [Monoid R] [CommMonoid S] (f : Π₀ i, β i) (g : ∀ i, β i → R →* S)
    (r : R) : (f.prod g) r = f.prod fun a b => (g a b) r 
goal: (f.sum g) r = f.sum fun a b => (g a b) r

full_name: MonoidHom.dfinsupp_prod_apply
code: @[to_additive]
theorem dfinsupp_prod_apply [Monoid R] [CommMonoid S] (f : Π₀ i, β i) (g : ∀ i, β i → R →* S)
    (r : R) : (f.prod g) r = f.prod fun a b => (g a b) r 
goal: (f.prod g) r = f.prod fun a b => (g a b) r

full_name: AddMonoidHom.map_dfinsupp_sumAddHom
code: @[simp]
theorem map_dfinsupp_sumAddHom [AddCommMonoid R] [AddCommMonoid S] [∀ i, AddZeroClass (β i)]
    (h : R →+ S) (f : Π₀ i, β i) (g : ∀ i, β i →+ R) :
    h (sumAddHom g f) = sumAddHom (fun i => h.comp (g i)) f 
goal: h ((DFinsupp.sumAddHom g) f) = (DFinsupp.sumAddHom fun i => h.comp (g i)) f

full_name: AddMonoidHom.dfinsupp_sumAddHom_apply
code: theorem dfinsupp_sumAddHom_apply [AddZeroClass R] [AddCommMonoid S] [∀ i, AddZeroClass (β i)]
    (f : Π₀ i, β i) (g : ∀ i, β i →+ R →+ S) (r : R) :
    (sumAddHom g f) r = sumAddHom (fun i => (eval r).comp (g i)) f 
goal: ((DFinsupp.sumAddHom g) f) r = (DFinsupp.sumAddHom fun i => (AddMonoidHom.eval r).comp (g i)) f

full_name: AddMonoidHom.coe_dfinsupp_sumAddHom
code: @[simp, norm_cast]
theorem coe_dfinsupp_sumAddHom [AddZeroClass R] [AddCommMonoid S] [∀ i, AddZeroClass (β i)]
    (f : Π₀ i, β i) (g : ∀ i, β i →+ R →+ S) :
    ⇑(sumAddHom g f) = sumAddHom (fun i => (coeFn R S).comp (g i)) f 
goal: ⇑((DFinsupp.sumAddHom g) f) = (DFinsupp.sumAddHom fun i => (AddMonoidHom.coeFn R S).comp (g i)) f

full_name: RingHom.map_dfinsupp_sumAddHom
code: @[simp]
theorem map_dfinsupp_sumAddHom [NonAssocSemiring R] [NonAssocSemiring S] [∀ i, AddZeroClass (β i)]
    (h : R →+* S) (f : Π₀ i, β i) (g : ∀ i, β i →+ R) :
    h (sumAddHom g f) = sumAddHom (fun i => h.toAddMonoidHom.comp (g i)) f 
goal: h ((DFinsupp.sumAddHom g) f) = (DFinsupp.sumAddHom fun i => h.toAddMonoidHom.comp (g i)) f

full_name: AddEquiv.map_dfinsupp_sumAddHom
code: @[simp]
theorem map_dfinsupp_sumAddHom [AddCommMonoid R] [AddCommMonoid S] [∀ i, AddZeroClass (β i)]
    (h : R ≃+ S) (f : Π₀ i, β i) (g : ∀ i, β i →+ R) :
    h (sumAddHom g f) = sumAddHom (fun i => h.toAddMonoidHom.comp (g i)) f 
goal: h ((DFinsupp.sumAddHom g) f) = (DFinsupp.sumAddHom fun i => h.toAddMonoidHom.comp (g i)) f

full_name: DFinsupp.fintype
code: instance DFinsupp.fintype {ι : Sort _} {π : ι → Sort _} [DecidableEq ι] [∀ i, Zero (π i)]
    [Fintype ι] [∀ i, Fintype (π i)] : Fintype (Π₀ i, π i) 
goal: Fintype (Π₀ (i : ι), π i)

full_name: DFinsupp.infinite_of_left
code: instance DFinsupp.infinite_of_left {ι : Sort _} {π : ι → Sort _} [∀ i, Nontrivial (π i)]
    [∀ i, Zero (π i)] [Infinite ι] : Infinite (Π₀ i, π i) 
goal: Infinite (Π₀ (i : ι), π i)

full_name: DFinsupp.infinite_of_exists_right
code: /-- See `DFinsupp.infinite_of_right` for this in instance form, with the drawback that
it needs all `π i` to be infinite. -/
theorem DFinsupp.infinite_of_exists_right {ι : Sort _} {π : ι → Sort _} (i : ι) [Infinite (π i)]
    [∀ i, Zero (π i)] : Infinite (Π₀ i, π i) 
goal: Infinite (Π₀ (i : ι), π i)

full_name: DFinsupp.infinite_of_right
code: /-- See `DFinsupp.infinite_of_exists_right` for the case that only one `π ι` is infinite. -/
instance DFinsupp.infinite_of_right {ι : Sort _} {π : ι → Sort _} [∀ i, Infinite (π i)]
    [∀ i, Zero (π i)] [Nonempty ι] : Infinite (Π₀ i, π i) 
goal: Infinite (Π₀ (i : ι), π i)