File: Mathlib/Data/Finsupp/ToDFinsupp.lean

full_name: Finsupp.toDFinsupp
code: /-- Interpret a `Finsupp` as a homogenous `DFinsupp`. -/
def Finsupp.toDFinsupp [Zero M] (f : ι →₀ M) : Π₀ _ : ι, M 
goal: Π₀ (x : ι), M

full_name: Finsupp.toDFinsupp_coe
code: @[simp]
theorem Finsupp.toDFinsupp_coe [Zero M] (f : ι →₀ M) : ⇑f.toDFinsupp = f 
goal: ⇑f.toDFinsupp = ⇑f

full_name: Finsupp.toDFinsupp_single
code: @[simp]
theorem Finsupp.toDFinsupp_single (i : ι) (m : M) :
    (Finsupp.single i m).toDFinsupp = DFinsupp.single i m 
goal: (Finsupp.single i m).toDFinsupp = DFinsupp.single i m

full_name: toDFinsupp_support
code: @[simp]
theorem toDFinsupp_support (f : ι →₀ M) : f.toDFinsupp.support = f.support 
goal: f.toDFinsupp.support = f.support

full_name: DFinsupp.toFinsupp
code: /-- Interpret a homogenous `DFinsupp` as a `Finsupp`.

Note that the elaborator has a lot of trouble with this definition - it is often necessary to
write `(DFinsupp.toFinsupp f : ι →₀ M)` instead of `f.toFinsupp`, as for some unknown reason
using dot notation or omitting the type ascription prevents the type being resolved correctly. -/
def DFinsupp.toFinsupp (f : Π₀ _ : ι, M) : ι →₀ M 
goal: ι →₀ M

full_name: DFinsupp.toFinsupp_coe
code: @[simp]
theorem DFinsupp.toFinsupp_coe (f : Π₀ _ : ι, M) : ⇑f.toFinsupp = f 
goal: ⇑f.toFinsupp = ⇑f

full_name: DFinsupp.toFinsupp_support
code: @[simp]
theorem DFinsupp.toFinsupp_support (f : Π₀ _ : ι, M) : f.toFinsupp.support = f.support 
goal: f.toFinsupp.support = f.support

full_name: DFinsupp.toFinsupp_single
code: @[simp]
theorem DFinsupp.toFinsupp_single (i : ι) (m : M) :
    (DFinsupp.single i m : Π₀ _ : ι, M).toFinsupp = Finsupp.single i m 
goal: (DFinsupp.single i m).toFinsupp = Finsupp.single i m

full_name: Finsupp.toDFinsupp_toFinsupp
code: @[simp]
theorem Finsupp.toDFinsupp_toFinsupp (f : ι →₀ M) : f.toDFinsupp.toFinsupp = f 
goal: f.toDFinsupp.toFinsupp = f

full_name: DFinsupp.toFinsupp_toDFinsupp
code: @[simp]
theorem DFinsupp.toFinsupp_toDFinsupp (f : Π₀ _ : ι, M) : f.toFinsupp.toDFinsupp = f 
goal: f.toFinsupp.toDFinsupp = f

full_name: Finsupp.toDFinsupp_zero
code: @[simp]
theorem toDFinsupp_zero [Zero M] : (0 : ι →₀ M).toDFinsupp = 0 
goal: Finsupp.toDFinsupp 0 = 0

full_name: Finsupp.toDFinsupp_add
code: @[simp]
theorem toDFinsupp_add [AddZeroClass M] (f g : ι →₀ M) :
    (f + g).toDFinsupp = f.toDFinsupp + g.toDFinsupp 
goal: (f + g).toDFinsupp = f.toDFinsupp + g.toDFinsupp

full_name: Finsupp.toDFinsupp_neg
code: @[simp]
theorem toDFinsupp_neg [AddGroup M] (f : ι →₀ M) : (-f).toDFinsupp = -f.toDFinsupp 
goal: (-f).toDFinsupp = -f.toDFinsupp

full_name: Finsupp.toDFinsupp_sub
code: @[simp]
theorem toDFinsupp_sub [AddGroup M] (f g : ι →₀ M) :
    (f - g).toDFinsupp = f.toDFinsupp - g.toDFinsupp 
goal: (f - g).toDFinsupp = f.toDFinsupp - g.toDFinsupp

full_name: Finsupp.toDFinsupp_smul
code: @[simp]
theorem toDFinsupp_smul [Monoid R] [AddMonoid M] [DistribMulAction R M] (r : R) (f : ι →₀ M) :
    (r • f).toDFinsupp = r • f.toDFinsupp 
goal: (r • f).toDFinsupp = r • f.toDFinsupp

full_name: DFinsupp.toFinsupp_zero
code: @[simp]
theorem toFinsupp_zero [Zero M] [∀ m : M, Decidable (m ≠ 0)] : toFinsupp 0 = (0 : ι →₀ M) 
goal: DFinsupp.toFinsupp 0 = 0

full_name: DFinsupp.toFinsupp_add
code: @[simp]
theorem toFinsupp_add [AddZeroClass M] [∀ m : M, Decidable (m ≠ 0)] (f g : Π₀ _ : ι, M) :
    (toFinsupp (f + g) : ι →₀ M) = toFinsupp f + toFinsupp g 
goal: (f + g).toFinsupp = f.toFinsupp + g.toFinsupp

full_name: DFinsupp.toFinsupp_neg
code: @[simp]
theorem toFinsupp_neg [AddGroup M] [∀ m : M, Decidable (m ≠ 0)] (f : Π₀ _ : ι, M) :
    (toFinsupp (-f) : ι →₀ M) = -toFinsupp f 
goal: (-f).toFinsupp = -f.toFinsupp

full_name: DFinsupp.toFinsupp_sub
code: @[simp]
theorem toFinsupp_sub [AddGroup M] [∀ m : M, Decidable (m ≠ 0)] (f g : Π₀ _ : ι, M) :
    (toFinsupp (f - g) : ι →₀ M) = toFinsupp f - toFinsupp g 
goal: (f - g).toFinsupp = f.toFinsupp - g.toFinsupp

full_name: DFinsupp.toFinsupp_smul
code: @[simp]
theorem toFinsupp_smul [Monoid R] [AddMonoid M] [DistribMulAction R M] [∀ m : M, Decidable (m ≠ 0)]
    (r : R) (f : Π₀ _ : ι, M) : (toFinsupp (r • f) : ι →₀ M) = r • toFinsupp f 
goal: (r • f).toFinsupp = r • f.toFinsupp

full_name: finsuppEquivDFinsupp_symm_apply
code: /-- `Finsupp.toDFinsupp` and `DFinsupp.toFinsupp` together form an equiv. -/
@[simps (config := .asFn)]
def finsuppEquivDFinsupp [DecidableEq ι] [Zero M] [∀ m : M, Decidable (m ≠ 0)] :
    (ι →₀ M) ≃ Π₀ _ : ι, M 
goal: ⇑finsuppEquivDFinsupp.symm = DFinsupp.toFinsupp

full_name: finsuppEquivDFinsupp
code: /-- `Finsupp.toDFinsupp` and `DFinsupp.toFinsupp` together form an equiv. -/
@[simps (config := .asFn)]
def finsuppEquivDFinsupp [DecidableEq ι] [Zero M] [∀ m : M, Decidable (m ≠ 0)] :
    (ι →₀ M) ≃ Π₀ _ : ι, M 
goal: (ι →₀ M) ≃ Π₀ (x : ι), M

full_name: finsuppEquivDFinsupp_apply
code: /-- `Finsupp.toDFinsupp` and `DFinsupp.toFinsupp` together form an equiv. -/
@[simps (config := .asFn)]
def finsuppEquivDFinsupp [DecidableEq ι] [Zero M] [∀ m : M, Decidable (m ≠ 0)] :
    (ι →₀ M) ≃ Π₀ _ : ι, M 
goal: ⇑finsuppEquivDFinsupp = Finsupp.toDFinsupp

full_name: finsuppAddEquivDFinsupp_apply
code: /-- The additive version of `finsupp.toFinsupp`. Note that this is `noncomputable` because
`Finsupp.add` is noncomputable. -/
@[simps (config := .asFn)]
def finsuppAddEquivDFinsupp [DecidableEq ι] [AddZeroClass M] [∀ m : M, Decidable (m ≠ 0)] :
    (ι →₀ M) ≃+ Π₀ _ : ι, M 
goal: ⇑finsuppAddEquivDFinsupp = Finsupp.toDFinsupp

full_name: finsuppAddEquivDFinsupp
code: /-- The additive version of `finsupp.toFinsupp`. Note that this is `noncomputable` because
`Finsupp.add` is noncomputable. -/
@[simps (config := .asFn)]
def finsuppAddEquivDFinsupp [DecidableEq ι] [AddZeroClass M] [∀ m : M, Decidable (m ≠ 0)] :
    (ι →₀ M) ≃+ Π₀ _ : ι, M 
goal: (ι →₀ M) ≃+ Π₀ (x : ι), M

full_name: finsuppAddEquivDFinsupp_symm_apply
code: /-- The additive version of `finsupp.toFinsupp`. Note that this is `noncomputable` because
`Finsupp.add` is noncomputable. -/
@[simps (config := .asFn)]
def finsuppAddEquivDFinsupp [DecidableEq ι] [AddZeroClass M] [∀ m : M, Decidable (m ≠ 0)] :
    (ι →₀ M) ≃+ Π₀ _ : ι, M 
goal: ⇑finsuppAddEquivDFinsupp.symm = DFinsupp.toFinsupp

full_name: finsuppLequivDFinsupp
code: /-- The additive version of `Finsupp.toFinsupp`. Note that this is `noncomputable` because
`Finsupp.add` is noncomputable. -/
-- Porting note: `simps` generated lemmas that did not pass `simpNF` lints, manually added below
--@[simps? (config := .asFn)]
def finsuppLequivDFinsupp [DecidableEq ι] [Semiring R] [AddCommMonoid M]
    [∀ m : M, Decidable (m ≠ 0)] [Module R M] : (ι →₀ M) ≃ₗ[R] Π₀ _ : ι, M 
goal: (ι →₀ M) ≃ₗ[R] Π₀ (x : ι), M

full_name: finsuppLequivDFinsupp_apply_apply
code: @[simp]
theorem finsuppLequivDFinsupp_apply_apply [DecidableEq ι] [Semiring R] [AddCommMonoid M]
    [∀ m : M, Decidable (m ≠ 0)] [Module R M] :
    (↑(finsuppLequivDFinsupp (M := M) R) : (ι →₀ M) → _) = Finsupp.toDFinsupp 
goal: ⇑(finsuppLequivDFinsupp R) = Finsupp.toDFinsupp

full_name: finsuppLequivDFinsupp_symm_apply
code: @[simp]
theorem finsuppLequivDFinsupp_symm_apply [DecidableEq ι] [Semiring R] [AddCommMonoid M]
    [∀ m : M, Decidable (m ≠ 0)] [Module R M] :
    ↑(LinearEquiv.symm (finsuppLequivDFinsupp (ι := ι) (M := M) R)) = DFinsupp.toFinsupp 
goal: ⇑(finsuppLequivDFinsupp R).symm = DFinsupp.toFinsupp

full_name: sigmaFinsuppEquivDFinsupp
code: /-- `Finsupp.split` is an equivalence between `(Σ i, η i) →₀ N` and `Π₀ i, (η i →₀ N)`. -/
def sigmaFinsuppEquivDFinsupp [Zero N] : ((Σi, η i) →₀ N) ≃ Π₀ i, η i →₀ N 
goal: ((i : ι) × η i →₀ N) ≃ Π₀ (i : ι), η i →₀ N

full_name: sigmaFinsuppEquivDFinsupp_apply
code: @[simp]
theorem sigmaFinsuppEquivDFinsupp_apply [Zero N] (f : (Σi, η i) →₀ N) :
    (sigmaFinsuppEquivDFinsupp f : ∀ i, η i →₀ N) = Finsupp.split f 
goal: ⇑(sigmaFinsuppEquivDFinsupp f) = f.split

full_name: sigmaFinsuppEquivDFinsupp_symm_apply
code: @[simp]
theorem sigmaFinsuppEquivDFinsupp_symm_apply [Zero N] (f : Π₀ i, η i →₀ N) (s : Σi, η i) :
    (sigmaFinsuppEquivDFinsupp.symm f : (Σi, η i) →₀ N) s = f s.1 s.2 
goal: (sigmaFinsuppEquivDFinsupp.symm f) s = (f s.fst) s.snd

full_name: sigmaFinsuppEquivDFinsupp_support
code: @[simp]
theorem sigmaFinsuppEquivDFinsupp_support [DecidableEq ι] [Zero N]
    [∀ (i : ι) (x : η i →₀ N), Decidable (x ≠ 0)] (f : (Σi, η i) →₀ N) :
    (sigmaFinsuppEquivDFinsupp f).support = Finsupp.splitSupport f 
goal: (sigmaFinsuppEquivDFinsupp f).support = f.splitSupport

full_name: sigmaFinsuppEquivDFinsupp_single
code: @[simp]
theorem sigmaFinsuppEquivDFinsupp_single [DecidableEq ι] [Zero N] (a : Σi, η i) (n : N) :
    sigmaFinsuppEquivDFinsupp (Finsupp.single a n) =
      @DFinsupp.single _ (fun i => η i →₀ N) _ _ a.1 (Finsupp.single a.2 n) 
goal: sigmaFinsuppEquivDFinsupp (Finsupp.single a n) = DFinsupp.single a.fst (Finsupp.single a.snd n)

full_name: sigmaFinsuppEquivDFinsupp_add
code: @[simp]
theorem sigmaFinsuppEquivDFinsupp_add [AddZeroClass N] (f g : (Σi, η i) →₀ N) :
    sigmaFinsuppEquivDFinsupp (f + g) =
      (sigmaFinsuppEquivDFinsupp f + sigmaFinsuppEquivDFinsupp g : Π₀ i : ι, η i →₀ N) 
goal: sigmaFinsuppEquivDFinsupp (f + g) = sigmaFinsuppEquivDFinsupp f + sigmaFinsuppEquivDFinsupp g

full_name: sigmaFinsuppAddEquivDFinsupp_apply
code: /-- `Finsupp.split` is an additive equivalence between `(Σ i, η i) →₀ N` and `Π₀ i, (η i →₀ N)`. -/
@[simps]
def sigmaFinsuppAddEquivDFinsupp [AddZeroClass N] : ((Σi, η i) →₀ N) ≃+ Π₀ i, η i →₀ N 
goal: sigmaFinsuppAddEquivDFinsupp a = sigmaFinsuppEquivDFinsupp a

full_name: sigmaFinsuppAddEquivDFinsupp_symm_apply
code: /-- `Finsupp.split` is an additive equivalence between `(Σ i, η i) →₀ N` and `Π₀ i, (η i →₀ N)`. -/
@[simps]
def sigmaFinsuppAddEquivDFinsupp [AddZeroClass N] : ((Σi, η i) →₀ N) ≃+ Π₀ i, η i →₀ N 
goal: sigmaFinsuppAddEquivDFinsupp.symm a = sigmaFinsuppEquivDFinsupp.symm a

full_name: sigmaFinsuppAddEquivDFinsupp
code: /-- `Finsupp.split` is an additive equivalence between `(Σ i, η i) →₀ N` and `Π₀ i, (η i →₀ N)`. -/
@[simps]
def sigmaFinsuppAddEquivDFinsupp [AddZeroClass N] : ((Σi, η i) →₀ N) ≃+ Π₀ i, η i →₀ N 
goal: ((i : ι) × η i →₀ N) ≃+ Π₀ (i : ι), η i →₀ N

full_name: sigmaFinsuppEquivDFinsupp_smul
code: @[simp]
theorem sigmaFinsuppEquivDFinsupp_smul {R} [Monoid R] [AddMonoid N] [DistribMulAction R N] (r : R)
    (f : (Σ i, η i) →₀ N) :
    sigmaFinsuppEquivDFinsupp (r • f) = r • sigmaFinsuppEquivDFinsupp f 
goal: sigmaFinsuppEquivDFinsupp (r • f) = r • sigmaFinsuppEquivDFinsupp f

full_name: sigmaFinsuppLequivDFinsupp_symm_apply
code: /-- `Finsupp.split` is a linear equivalence between `(Σ i, η i) →₀ N` and `Π₀ i, (η i →₀ N)`. -/
@[simps]
def sigmaFinsuppLequivDFinsupp [AddCommMonoid N] [Module R N] :
    ((Σi, η i) →₀ N) ≃ₗ[R] Π₀ i, η i →₀ N 
goal: (sigmaFinsuppLequivDFinsupp R).symm a = sigmaFinsuppEquivDFinsupp.symm a

full_name: sigmaFinsuppLequivDFinsupp_apply
code: /-- `Finsupp.split` is a linear equivalence between `(Σ i, η i) →₀ N` and `Π₀ i, (η i →₀ N)`. -/
@[simps]
def sigmaFinsuppLequivDFinsupp [AddCommMonoid N] [Module R N] :
    ((Σi, η i) →₀ N) ≃ₗ[R] Π₀ i, η i →₀ N 
goal: (sigmaFinsuppLequivDFinsupp R) a = sigmaFinsuppEquivDFinsupp a

full_name: sigmaFinsuppLequivDFinsupp
code: /-- `Finsupp.split` is a linear equivalence between `(Σ i, η i) →₀ N` and `Π₀ i, (η i →₀ N)`. -/
@[simps]
def sigmaFinsuppLequivDFinsupp [AddCommMonoid N] [Module R N] :
    ((Σi, η i) →₀ N) ≃ₗ[R] Π₀ i, η i →₀ N 
goal: ((i : ι) × η i →₀ N) ≃ₗ[R] Π₀ (i : ι), η i →₀ N