File: Mathlib/LinearAlgebra/Finsupp.lean

full_name: Finsupp.smul_sum
code: theorem smul_sum [Zero β] [AddCommMonoid M] [DistribSMul R M] {v : α →₀ β} {c : R} {h : α → β → M} :
    c • v.sum h = v.sum fun a b => c • h a b 
goal: c • v.sum h = v.sum fun a b => c • h a b

full_name: Finsupp.sum_smul_index_linearMap'
code: @[simp]
theorem sum_smul_index_linearMap' [Semiring R] [AddCommMonoid M] [Module R M] [AddCommMonoid M₂]
    [Module R M₂] {v : α →₀ M} {c : R} {h : α → M →ₗ[R] M₂} :
    ((c • v).sum fun a => h a) = c • v.sum fun a => h a 
goal: ((c • v).sum fun a => ⇑(h a)) = c • v.sum fun a => ⇑(h a)

full_name: Finsupp.linearEquivFunOnFinite
code: /-- Given `Finite α`, `linearEquivFunOnFinite R` is the natural `R`-linear equivalence between
`α →₀ β` and `α → β`. -/
@[simps apply]
noncomputable def linearEquivFunOnFinite : (α →₀ M) ≃ₗ[R] α → M 
goal: (α →₀ M) ≃ₗ[R] α → M

full_name: Finsupp.linearEquivFunOnFinite_apply
code: /-- Given `Finite α`, `linearEquivFunOnFinite R` is the natural `R`-linear equivalence between
`α →₀ β` and `α → β`. -/
@[simps apply]
noncomputable def linearEquivFunOnFinite : (α →₀ M) ≃ₗ[R] α → M 
goal: ∀ (a : α →₀ M) (a_1 : α), (Finsupp.linearEquivFunOnFinite R M α) a a_1 = a a_1

full_name: Finsupp.linearEquivFunOnFinite_single
code: @[simp]
theorem linearEquivFunOnFinite_single [DecidableEq α] (x : α) (m : M) :
    (linearEquivFunOnFinite R M α) (single x m) = Pi.single x m 
goal: (Finsupp.linearEquivFunOnFinite R M α) (Finsupp.single x m) = Pi.single x m

full_name: Finsupp.linearEquivFunOnFinite_symm_single
code: @[simp]
theorem linearEquivFunOnFinite_symm_single [DecidableEq α] (x : α) (m : M) :
    (linearEquivFunOnFinite R M α).symm (Pi.single x m) = single x m 
goal: (Finsupp.linearEquivFunOnFinite R M α).symm (Pi.single x m) = Finsupp.single x m

full_name: Finsupp.linearEquivFunOnFinite_symm_coe
code: @[simp]
theorem linearEquivFunOnFinite_symm_coe (f : α →₀ M) : (linearEquivFunOnFinite R M α).symm f = f 
goal: (Finsupp.linearEquivFunOnFinite R M α).symm ⇑f = f

full_name: Finsupp.LinearEquiv.finsuppUnique
code: /-- If `α` has a unique term, then the type of finitely supported functions `α →₀ M` is
`R`-linearly equivalent to `M`. -/
noncomputable def LinearEquiv.finsuppUnique : (α →₀ M) ≃ₗ[R] M 
goal: (α →₀ M) ≃ₗ[R] M

full_name: Finsupp.LinearEquiv.finsuppUnique_apply
code: @[simp]
theorem LinearEquiv.finsuppUnique_apply (f : α →₀ M) :
    LinearEquiv.finsuppUnique R M α f = f default 
goal: (Finsupp.LinearEquiv.finsuppUnique R M α) f = f default

full_name: Finsupp.LinearEquiv.finsuppUnique_symm_apply
code: @[simp]
theorem LinearEquiv.finsuppUnique_symm_apply [Unique α] (m : M) :
    (LinearEquiv.finsuppUnique R M α).symm m = Finsupp.single default m 
goal: (Finsupp.LinearEquiv.finsuppUnique R M α).symm m = Finsupp.single default m

full_name: Finsupp.lsingle
code: /-- Interpret `Finsupp.single a` as a linear map. -/
def lsingle (a : α) : M →ₗ[R] α →₀ M 
goal: M →ₗ[R] α →₀ M

full_name: Finsupp.lhom_ext
code: /-- Two `R`-linear maps from `Finsupp X M` which agree on each `single x y` agree everywhere. -/
theorem lhom_ext ⦃φ ψ : (α →₀ M) →ₗ[R] N⦄ (h : ∀ a b, φ (single a b) = ψ (single a b)) : φ = ψ 
goal: φ = ψ

full_name: Finsupp.lhom_ext'
code: /-- Two `R`-linear maps from `Finsupp X M` which agree on each `single x y` agree everywhere.

We formulate this fact using equality of linear maps `φ.comp (lsingle a)` and `ψ.comp (lsingle a)`
so that the `ext` tactic can apply a type-specific extensionality lemma to prove equality of these
maps. E.g., if `M = R`, then it suffices to verify `φ (single a 1) = ψ (single a 1)`. -/
-- Porting note: The priority should be higher than `LinearMap.ext`.
@[ext high]
theorem lhom_ext' ⦃φ ψ : (α →₀ M) →ₗ[R] N⦄ (h : ∀ a, φ.comp (lsingle a) = ψ.comp (lsingle a)) :
    φ = ψ 
goal: φ = ψ

full_name: Finsupp.lapply
code: /-- Interpret `fun f : α →₀ M ↦ f a` as a linear map. -/
def lapply (a : α) : (α →₀ M) →ₗ[R] M 
goal: (α →₀ M) →ₗ[R] M

full_name: LinearMap.CompatibleSMul.finsupp_dom
code: instance _root_.LinearMap.CompatibleSMul.finsupp_dom [SMulZeroClass R M] [DistribSMul R N]
    [LinearMap.CompatibleSMul M N R S] : LinearMap.CompatibleSMul (ι →₀ M) N R S 
goal: LinearMap.CompatibleSMul (ι →₀ M) N R S

full_name: LinearMap.CompatibleSMul.finsupp_cod
code: instance _root_.LinearMap.CompatibleSMul.finsupp_cod [SMul R M] [SMulZeroClass R N]
    [LinearMap.CompatibleSMul M N R S] : LinearMap.CompatibleSMul M (ι →₀ N) R S 
goal: LinearMap.CompatibleSMul M (ι →₀ N) R S

full_name: Finsupp.lcoeFun_apply
code: /-- Forget that a function is finitely supported.

This is the linear version of `Finsupp.toFun`. -/
@[simps]
def lcoeFun : (α →₀ M) →ₗ[R] α → M 
goal: ∀ (a : α →₀ M) (a_1 : α), Finsupp.lcoeFun a a_1 = a a_1

full_name: Finsupp.lcoeFun
code: /-- Forget that a function is finitely supported.

This is the linear version of `Finsupp.toFun`. -/
@[simps]
def lcoeFun : (α →₀ M) →ₗ[R] α → M 
goal: (α →₀ M) →ₗ[R] α → M

full_name: Finsupp.lsubtypeDomain
code: /-- Interpret `Finsupp.subtypeDomain s` as a linear map. -/
def lsubtypeDomain : (α →₀ M) →ₗ[R] s →₀ M 
goal: (α →₀ M) →ₗ[R] ↑s →₀ M

full_name: Finsupp.lsubtypeDomain_apply
code: theorem lsubtypeDomain_apply (f : α →₀ M) :
    (lsubtypeDomain s : (α →₀ M) →ₗ[R] s →₀ M) f = subtypeDomain (fun x => x ∈ s) f 
goal: (Finsupp.lsubtypeDomain s) f = Finsupp.subtypeDomain (fun x => x ∈ s) f

full_name: Finsupp.lsingle_apply
code: @[simp]
theorem lsingle_apply (a : α) (b : M) : (lsingle a : M →ₗ[R] α →₀ M) b = single a b 
goal: (Finsupp.lsingle a) b = Finsupp.single a b

full_name: Finsupp.lapply_apply
code: @[simp]
theorem lapply_apply (a : α) (f : α →₀ M) : (lapply a : (α →₀ M) →ₗ[R] M) f = f a 
goal: (Finsupp.lapply a) f = f a

full_name: Finsupp.lapply_comp_lsingle_same
code: @[simp]
theorem lapply_comp_lsingle_same (a : α) : lapply a ∘ₗ lsingle a = (.id : M →ₗ[R] M) 
goal: Finsupp.lapply a ∘ₗ Finsupp.lsingle a = LinearMap.id

full_name: Finsupp.lapply_comp_lsingle_of_ne
code: @[simp]
theorem lapply_comp_lsingle_of_ne (a a' : α) (h : a ≠ a') :
    lapply a ∘ₗ lsingle a' = (0 : M →ₗ[R] M) 
goal: Finsupp.lapply a ∘ₗ Finsupp.lsingle a' = 0

full_name: Finsupp.ker_lsingle
code: @[simp]
theorem ker_lsingle (a : α) : ker (lsingle a : M →ₗ[R] α →₀ M) = ⊥ 
goal: LinearMap.ker (Finsupp.lsingle a) = ⊥

full_name: Finsupp.lsingle_range_le_ker_lapply
code: theorem lsingle_range_le_ker_lapply (s t : Set α) (h : Disjoint s t) :
    ⨆ a ∈ s, LinearMap.range (lsingle a : M →ₗ[R] α →₀ M) ≤
      ⨅ a ∈ t, ker (lapply a : (α →₀ M) →ₗ[R] M) 
goal: ⨆ a ∈ s, LinearMap.range (Finsupp.lsingle a) ≤ ⨅ a ∈ t, LinearMap.ker (Finsupp.lapply a)

full_name: Finsupp.iInf_ker_lapply_le_bot
code: theorem iInf_ker_lapply_le_bot : ⨅ a, ker (lapply a : (α →₀ M) →ₗ[R] M) ≤ ⊥ 
goal: ⨅ a, LinearMap.ker (Finsupp.lapply a) ≤ ⊥

full_name: Finsupp.iSup_lsingle_range
code: theorem iSup_lsingle_range : ⨆ a, LinearMap.range (lsingle a : M →ₗ[R] α →₀ M) = ⊤ 
goal: ⨆ a, LinearMap.range (Finsupp.lsingle a) = ⊤

full_name: Finsupp.disjoint_lsingle_lsingle
code: theorem disjoint_lsingle_lsingle (s t : Set α) (hs : Disjoint s t) :
    Disjoint (⨆ a ∈ s, LinearMap.range (lsingle a : M →ₗ[R] α →₀ M))
      (⨆ a ∈ t, LinearMap.range (lsingle a : M →ₗ[R] α →₀ M)) 
goal: Disjoint (⨆ a ∈ s, LinearMap.range (Finsupp.lsingle a)) (⨆ a ∈ t, LinearMap.range (Finsupp.lsingle a))

full_name: Finsupp.span_single_image
code: theorem span_single_image (s : Set M) (a : α) :
    Submodule.span R (single a '' s) = (Submodule.span R s).map (lsingle a : M →ₗ[R] α →₀ M) 
goal: Submodule.span R (Finsupp.single a '' s) = Submodule.map (Finsupp.lsingle a) (Submodule.span R s)

full_name: Finsupp.supported
code: /-- `Finsupp.supported M R s` is the `R`-submodule of all `p : α →₀ M` such that `p.support ⊆ s`. -/
def supported (s : Set α) : Submodule R (α →₀ M) 
goal: Submodule R (α →₀ M)

full_name: Finsupp.mem_supported
code: theorem mem_supported {s : Set α} (p : α →₀ M) : p ∈ supported M R s ↔ ↑p.support ⊆ s 
goal: p ∈ Finsupp.supported M R s ↔ ↑p.support ⊆ s

full_name: Finsupp.mem_supported'
code: theorem mem_supported' {s : Set α} (p : α →₀ M) :
    p ∈ supported M R s ↔ ∀ x ∉ s, p x = 0 
goal: p ∈ Finsupp.supported M R s ↔ ∀ x ∉ s, p x = 0

full_name: Finsupp.mem_supported_support
code: theorem mem_supported_support (p : α →₀ M) : p ∈ Finsupp.supported M R (p.support : Set α) 
goal: p ∈ Finsupp.supported M R ↑p.support

full_name: Finsupp.single_mem_supported
code: theorem single_mem_supported {s : Set α} {a : α} (b : M) (h : a ∈ s) :
    single a b ∈ supported M R s 
goal: Finsupp.single a b ∈ Finsupp.supported M R s

full_name: Finsupp.supported_eq_span_single
code: theorem supported_eq_span_single (s : Set α) :
    supported R R s = span R ((fun i => single i 1) '' s) 
goal: Finsupp.supported R R s = Submodule.span R ((fun i => Finsupp.single i 1) '' s)

full_name: Finsupp.restrictDom
code: /-- Interpret `Finsupp.filter s` as a linear map from `α →₀ M` to `supported M R s`. -/
def restrictDom (s : Set α) [DecidablePred (· ∈ s)] : (α →₀ M) →ₗ[R] supported M R s 
goal: (α →₀ M) →ₗ[R] ↥(Finsupp.supported M R s)

full_name: Finsupp.restrictDom_apply
code: @[simp]
theorem restrictDom_apply (s : Set α) (l : α →₀ M) [DecidablePred (· ∈ s)] :
    (restrictDom M R s l : α →₀ M) = Finsupp.filter (· ∈ s) l 
goal: ↑((Finsupp.restrictDom M R s) l) = Finsupp.filter (fun x => x ∈ s) l

full_name: Finsupp.restrictDom_comp_subtype
code: theorem restrictDom_comp_subtype (s : Set α) [DecidablePred (· ∈ s)] :
    (restrictDom M R s).comp (Submodule.subtype _) = LinearMap.id 
goal: Finsupp.restrictDom M R s ∘ₗ (Finsupp.supported M R s).subtype = LinearMap.id

full_name: Finsupp.range_restrictDom
code: theorem range_restrictDom (s : Set α) [DecidablePred (· ∈ s)] :
    LinearMap.range (restrictDom M R s) = ⊤ 
goal: LinearMap.range (Finsupp.restrictDom M R s) = ⊤

full_name: Finsupp.supported_mono
code: theorem supported_mono {s t : Set α} (st : s ⊆ t) : supported M R s ≤ supported M R t 
goal: Finsupp.supported M R s ≤ Finsupp.supported M R t

full_name: Finsupp.supported_empty
code: @[simp]
theorem supported_empty : supported M R (∅ : Set α) = ⊥ 
goal: Finsupp.supported M R ∅ = ⊥

full_name: Finsupp.supported_univ
code: @[simp]
theorem supported_univ : supported M R (Set.univ : Set α) = ⊤ 
goal: Finsupp.supported M R Set.univ = ⊤

full_name: Finsupp.supported_iUnion
code: theorem supported_iUnion {δ : Type*} (s : δ → Set α) :
    supported M R (⋃ i, s i) = ⨆ i, supported M R (s i) 
goal: Finsupp.supported M R (⋃ i, s i) = ⨆ i, Finsupp.supported M R (s i)

full_name: Finsupp.supported_union
code: theorem supported_union (s t : Set α) :
    supported M R (s ∪ t) = supported M R s ⊔ supported M R t 
goal: Finsupp.supported M R (s ∪ t) = Finsupp.supported M R s ⊔ Finsupp.supported M R t

full_name: Finsupp.supported_iInter
code: theorem supported_iInter {ι : Type*} (s : ι → Set α) :
    supported M R (⋂ i, s i) = ⨅ i, supported M R (s i) 
goal: Finsupp.supported M R (⋂ i, s i) = ⨅ i, Finsupp.supported M R (s i)

full_name: Finsupp.supported_inter
code: theorem supported_inter (s t : Set α) :
    supported M R (s ∩ t) = supported M R s ⊓ supported M R t 
goal: Finsupp.supported M R (s ∩ t) = Finsupp.supported M R s ⊓ Finsupp.supported M R t

full_name: Finsupp.disjoint_supported_supported
code: theorem disjoint_supported_supported {s t : Set α} (h : Disjoint s t) :
    Disjoint (supported M R s) (supported M R t) 
goal: Disjoint (Finsupp.supported M R s) (Finsupp.supported M R t)

full_name: Finsupp.disjoint_supported_supported_iff
code: theorem disjoint_supported_supported_iff [Nontrivial M] {s t : Set α} :
    Disjoint (supported M R s) (supported M R t) ↔ Disjoint s t 
goal: Disjoint (Finsupp.supported M R s) (Finsupp.supported M R t) ↔ Disjoint s t

full_name: Finsupp.supportedEquivFinsupp
code: /-- Interpret `Finsupp.restrictSupportEquiv` as a linear equivalence between
`supported M R s` and `s →₀ M`. -/
def supportedEquivFinsupp (s : Set α) : supported M R s ≃ₗ[R] s →₀ M 
goal: ↥(Finsupp.supported M R s) ≃ₗ[R] ↑s →₀ M

full_name: Finsupp.lsum
code: /-- Lift a family of linear maps `M →ₗ[R] N` indexed by `x : α` to a linear map from `α →₀ M` to
`N` using `Finsupp.sum`. This is an upgraded version of `Finsupp.liftAddHom`.

See note [bundled maps over different rings] for why separate `R` and `S` semirings are used.
-/
def lsum : (α → M →ₗ[R] N) ≃ₗ[S] (α →₀ M) →ₗ[R] N 
goal: (α → M →ₗ[R] N) ≃ₗ[S] (α →₀ M) →ₗ[R] N

full_name: Finsupp.coe_lsum
code: @[simp]
theorem coe_lsum (f : α → M →ₗ[R] N) : (lsum S f : (α →₀ M) → N) = fun d => d.sum fun i => f i 
goal: ⇑((Finsupp.lsum S) f) = fun d => d.sum fun i => ⇑(f i)

full_name: Finsupp.lsum_apply
code: theorem lsum_apply (f : α → M →ₗ[R] N) (l : α →₀ M) : Finsupp.lsum S f l = l.sum fun b => f b 
goal: ((Finsupp.lsum S) f) l = l.sum fun b => ⇑(f b)

full_name: Finsupp.lsum_single
code: theorem lsum_single (f : α → M →ₗ[R] N) (i : α) (m : M) :
    Finsupp.lsum S f (Finsupp.single i m) = f i m 
goal: ((Finsupp.lsum S) f) (Finsupp.single i m) = (f i) m

full_name: Finsupp.lsum_comp_lsingle
code: @[simp] theorem lsum_comp_lsingle (f : α → M →ₗ[R] N) (i : α) :
    Finsupp.lsum S f ∘ₗ lsingle i = f i 
goal: (Finsupp.lsum S) f ∘ₗ Finsupp.lsingle i = f i

full_name: Finsupp.lsum_symm_apply
code: theorem lsum_symm_apply (f : (α →₀ M) →ₗ[R] N) (x : α) : (lsum S).symm f x = f.comp (lsingle x) 
goal: (Finsupp.lsum S).symm f x = f ∘ₗ Finsupp.lsingle x

full_name: Finsupp.lift
code: /-- A slight rearrangement from `lsum` gives us
the bijection underlying the free-forgetful adjunction for R-modules.
-/
noncomputable def lift : (X → M) ≃+ ((X →₀ R) →ₗ[R] M) 
goal: (X → M) ≃+ ((X →₀ R) →ₗ[R] M)

full_name: Finsupp.lift_symm_apply
code: @[simp]
theorem lift_symm_apply (f) (x) : ((lift M R X).symm f) x = f (single x 1) 
goal: (Finsupp.lift M R X).symm f x = f (Finsupp.single x 1)

full_name: Finsupp.lift_apply
code: @[simp]
theorem lift_apply (f) (g) : ((lift M R X) f) g = g.sum fun x r => r • f x 
goal: ((Finsupp.lift M R X) f) g = g.sum fun x r => r • f x

full_name: Finsupp.llift
code: /-- Given compatible `S` and `R`-module structures on `M` and a type `X`, the set of functions
`X → M` is `S`-linearly equivalent to the `R`-linear maps from the free `R`-module
on `X` to `M`. -/
noncomputable def llift : (X → M) ≃ₗ[S] (X →₀ R) →ₗ[R] M 
goal: (X → M) ≃ₗ[S] (X →₀ R) →ₗ[R] M

full_name: Finsupp.llift_apply
code: @[simp]
theorem llift_apply (f : X → M) (x : X →₀ R) : llift M R S X f x = lift M R X f x 
goal: ((Finsupp.llift M R S X) f) x = ((Finsupp.lift M R X) f) x

full_name: Finsupp.llift_symm_apply
code: @[simp]
theorem llift_symm_apply (f : (X →₀ R) →ₗ[R] M) (x : X) :
    (llift M R S X).symm f x = f (single x 1) 
goal: (Finsupp.llift M R S X).symm f x = f (Finsupp.single x 1)

full_name: Finsupp.lmapDomain
code: /-- Interpret `Finsupp.mapDomain` as a linear map. -/
def lmapDomain (f : α → α') : (α →₀ M) →ₗ[R] α' →₀ M 
goal: (α →₀ M) →ₗ[R] α' →₀ M

full_name: Finsupp.lmapDomain_apply
code: @[simp]
theorem lmapDomain_apply (f : α → α') (l : α →₀ M) :
    (lmapDomain M R f : (α →₀ M) →ₗ[R] α' →₀ M) l = mapDomain f l 
goal: (Finsupp.lmapDomain M R f) l = Finsupp.mapDomain f l

full_name: Finsupp.lmapDomain_id
code: @[simp]
theorem lmapDomain_id : (lmapDomain M R _root_.id : (α →₀ M) →ₗ[R] α →₀ M) = LinearMap.id 
goal: Finsupp.lmapDomain M R id = LinearMap.id

full_name: Finsupp.lmapDomain_comp
code: theorem lmapDomain_comp (f : α → α') (g : α' → α'') :
    lmapDomain M R (g ∘ f) = (lmapDomain M R g).comp (lmapDomain M R f) 
goal: Finsupp.lmapDomain M R (g ∘ f) = Finsupp.lmapDomain M R g ∘ₗ Finsupp.lmapDomain M R f

full_name: Finsupp.supported_comap_lmapDomain
code: theorem supported_comap_lmapDomain (f : α → α') (s : Set α') :
    supported M R (f ⁻¹' s) ≤ (supported M R s).comap (lmapDomain M R f) 
goal: Finsupp.supported M R (f ⁻¹' s) ≤ Submodule.comap (Finsupp.lmapDomain M R f) (Finsupp.supported M R s)

full_name: Finsupp.lmapDomain_supported
code: theorem lmapDomain_supported (f : α → α') (s : Set α) :
    (supported M R s).map (lmapDomain M R f) = supported M R (f '' s) 
goal: Submodule.map (Finsupp.lmapDomain M R f) (Finsupp.supported M R s) = Finsupp.supported M R (f '' s)

full_name: Finsupp.lmapDomain_disjoint_ker
code: theorem lmapDomain_disjoint_ker (f : α → α') {s : Set α}
    (H : ∀ a ∈ s, ∀ b ∈ s, f a = f b → a = b) :
    Disjoint (supported M R s) (ker (lmapDomain M R f)) 
goal: Disjoint (Finsupp.supported M R s) (LinearMap.ker (Finsupp.lmapDomain M R f))

full_name: Finsupp.lcomapDomain
code: /-- Given `f : α → β` and a proof `hf` that `f` is injective, `lcomapDomain f hf` is the linear map
sending `l : β →₀ M` to the finitely supported function from `α` to `M` given by composing
`l` with `f`.

This is the linear version of `Finsupp.comapDomain`. -/
def lcomapDomain (f : α → β) (hf : Function.Injective f) : (β →₀ M) →ₗ[R] α →₀ M 
goal: (β →₀ M) →ₗ[R] α →₀ M

full_name: Finsupp.total
code: /-- Interprets (l : α →₀ R) as linear combination of the elements in the family (v : α → M) and
    evaluates this linear combination. -/
protected def total : (α →₀ R) →ₗ[R] M 
goal: (α →₀ R) →ₗ[R] M

full_name: Finsupp.total_apply
code: theorem total_apply (l : α →₀ R) : Finsupp.total α M R v l = l.sum fun i a => a • v i 
goal: (Finsupp.total α M R v) l = l.sum fun i a => a • v i

full_name: Finsupp.total_apply_of_mem_supported
code: theorem total_apply_of_mem_supported {l : α →₀ R} {s : Finset α}
    (hs : l ∈ supported R R (↑s : Set α)) : Finsupp.total α M R v l = s.sum fun i => l i • v i 
goal: (Finsupp.total α M R v) l = ∑ i ∈ s, l i • v i

full_name: Finsupp.total_single
code: @[simp]
theorem total_single (c : R) (a : α) : Finsupp.total α M R v (single a c) = c • v a 
goal: (Finsupp.total α M R v) (Finsupp.single a c) = c • v a

full_name: Finsupp.total_zero_apply
code: theorem total_zero_apply (x : α →₀ R) : (Finsupp.total α M R 0) x = 0 
goal: (Finsupp.total α M R 0) x = 0

full_name: Finsupp.total_zero
code: @[simp]
theorem total_zero : Finsupp.total α M R 0 = 0 
goal: Finsupp.total α M R 0 = 0

full_name: Finsupp.apply_total
code: theorem apply_total (f : M →ₗ[R] M') (v) (l : α →₀ R) :
    f (Finsupp.total α M R v l) = Finsupp.total α M' R (f ∘ v) l 
goal: f ((Finsupp.total α M R v) l) = (Finsupp.total α M' R (⇑f ∘ v)) l

full_name: Finsupp.apply_total_id
code: theorem apply_total_id (f : M →ₗ[R] M') (l : M →₀ R) :
    f (Finsupp.total M M R _root_.id l) = Finsupp.total M M' R f l 
goal: f ((Finsupp.total M M R id) l) = (Finsupp.total M M' R ⇑f) l

full_name: Finsupp.total_unique
code: theorem total_unique [Unique α] (l : α →₀ R) (v) :
    Finsupp.total α M R v l = l default • v default 
goal: (Finsupp.total α M R v) l = l default • v default

full_name: Finsupp.total_surjective
code: theorem total_surjective (h : Function.Surjective v) :
    Function.Surjective (Finsupp.total α M R v) 
goal: Function.Surjective ⇑(Finsupp.total α M R v)

full_name: Finsupp.total_range
code: theorem total_range (h : Function.Surjective v) : LinearMap.range (Finsupp.total α M R v) = ⊤ 
goal: LinearMap.range (Finsupp.total α M R v) = ⊤

full_name: Finsupp.total_id_surjective
code: /-- Any module is a quotient of a free module. This is stated as surjectivity of
`Finsupp.total M M R id : (M →₀ R) →ₗ[R] M`. -/
theorem total_id_surjective (M) [AddCommMonoid M] [Module R M] :
    Function.Surjective (Finsupp.total M M R _root_.id) 
goal: Function.Surjective ⇑(Finsupp.total M M R id)

full_name: Finsupp.range_total
code: theorem range_total : LinearMap.range (Finsupp.total α M R v) = span R (range v) 
goal: LinearMap.range (Finsupp.total α M R v) = Submodule.span R (Set.range v)

full_name: Finsupp.lmapDomain_total
code: theorem lmapDomain_total (f : α → α') (g : M →ₗ[R] M') (h : ∀ i, g (v i) = v' (f i)) :
    (Finsupp.total α' M' R v').comp (lmapDomain R R f) = g.comp (Finsupp.total α M R v) 
goal: Finsupp.total α' M' R v' ∘ₗ Finsupp.lmapDomain R R f = g ∘ₗ Finsupp.total α M R v

full_name: Finsupp.total_comp_lmapDomain
code: theorem total_comp_lmapDomain (f : α → α') :
    (Finsupp.total α' M' R v').comp (Finsupp.lmapDomain R R f) = Finsupp.total α M' R (v' ∘ f) 
goal: Finsupp.total α' M' R v' ∘ₗ Finsupp.lmapDomain R R f = Finsupp.total α M' R (v' ∘ f)

full_name: Finsupp.total_embDomain
code: @[simp]
theorem total_embDomain (f : α ↪ α') (l : α →₀ R) :
    (Finsupp.total α' M' R v') (embDomain f l) = (Finsupp.total α M' R (v' ∘ f)) l 
goal: (Finsupp.total α' M' R v') (Finsupp.embDomain f l) = (Finsupp.total α M' R (v' ∘ ⇑f)) l

full_name: Finsupp.total_mapDomain
code: @[simp]
theorem total_mapDomain (f : α → α') (l : α →₀ R) :
    (Finsupp.total α' M' R v') (mapDomain f l) = (Finsupp.total α M' R (v' ∘ f)) l 
goal: (Finsupp.total α' M' R v') (Finsupp.mapDomain f l) = (Finsupp.total α M' R (v' ∘ f)) l

full_name: Finsupp.total_equivMapDomain
code: @[simp]
theorem total_equivMapDomain (f : α ≃ α') (l : α →₀ R) :
    (Finsupp.total α' M' R v') (equivMapDomain f l) = (Finsupp.total α M' R (v' ∘ f)) l 
goal: (Finsupp.total α' M' R v') (Finsupp.equivMapDomain f l) = (Finsupp.total α M' R (v' ∘ ⇑f)) l

full_name: Finsupp.span_eq_range_total
code: /-- A version of `Finsupp.range_total` which is useful for going in the other direction -/
theorem span_eq_range_total (s : Set M) : span R s = LinearMap.range (Finsupp.total s M R (↑)) 
goal: Submodule.span R s = LinearMap.range (Finsupp.total (↑s) M R Subtype.val)

full_name: Finsupp.mem_span_iff_total
code: theorem mem_span_iff_total (s : Set M) (x : M) :
    x ∈ span R s ↔ ∃ l : s →₀ R, Finsupp.total s M R (↑) l = x 
goal: x ∈ Submodule.span R s ↔ ∃ l, (Finsupp.total (↑s) M R Subtype.val) l = x

full_name: Finsupp.mem_span_range_iff_exists_finsupp
code: theorem mem_span_range_iff_exists_finsupp {v : α → M} {x : M} :
    x ∈ span R (range v) ↔ ∃ c : α →₀ R, (c.sum fun i a => a • v i) = x 
goal: x ∈ Submodule.span R (Set.range v) ↔ ∃ c, (c.sum fun i a => a • v i) = x

full_name: Finsupp.span_image_eq_map_total
code: theorem span_image_eq_map_total (s : Set α) :
    span R (v '' s) = Submodule.map (Finsupp.total α M R v) (supported R R s) 
goal: Submodule.span R (v '' s) = Submodule.map (Finsupp.total α M R v) (Finsupp.supported R R s)

full_name: Finsupp.mem_span_image_iff_total
code: theorem mem_span_image_iff_total {s : Set α} {x : M} :
    x ∈ span R (v '' s) ↔ ∃ l ∈ supported R R s, Finsupp.total α M R v l = x 
goal: x ∈ Submodule.span R (v '' s) ↔ ∃ l ∈ Finsupp.supported R R s, (Finsupp.total α M R v) l = x

full_name: Finsupp.total_option
code: theorem total_option (v : Option α → M) (f : Option α →₀ R) :
    Finsupp.total (Option α) M R v f =
      f none • v none + Finsupp.total α M R (v ∘ Option.some) f.some 
goal: (Finsupp.total (Option α) M R v) f = f none • v none + (Finsupp.total α M R (v ∘ some)) f.some

full_name: Finsupp.total_total
code: theorem total_total {α β : Type*} (A : α → M) (B : β → α →₀ R) (f : β →₀ R) :
    Finsupp.total α M R A (Finsupp.total β (α →₀ R) R B f) =
      Finsupp.total β M R (fun b => Finsupp.total α M R A (B b)) f 
goal: (Finsupp.total α M R A) ((Finsupp.total β (α →₀ R) R B) f) =
  (Finsupp.total β M R fun b => (Finsupp.total α M R A) (B b)) f

full_name: Finsupp.total_fin_zero
code: @[simp]
theorem total_fin_zero (f : Fin 0 → M) : Finsupp.total (Fin 0) M R f = 0 
goal: Finsupp.total (Fin 0) M R f = 0

full_name: Finsupp.totalOn
code: /-- `Finsupp.totalOn M v s` interprets `p : α →₀ R` as a linear combination of a
subset of the vectors in `v`, mapping it to the span of those vectors.

The subset is indicated by a set `s : Set α` of indices.
-/
protected def totalOn (s : Set α) : supported R R s →ₗ[R] span R (v '' s) 
goal: ↥(Finsupp.supported R R s) →ₗ[R] ↥(Submodule.span R (v '' s))

full_name: Finsupp.totalOn_range
code: theorem totalOn_range (s : Set α) : LinearMap.range (Finsupp.totalOn α M R v s) = ⊤ 
goal: LinearMap.range (Finsupp.totalOn α M R v s) = ⊤

full_name: Finsupp.total_comp
code: theorem total_comp (f : α' → α) :
    Finsupp.total α' M R (v ∘ f) = (Finsupp.total α M R v).comp (lmapDomain R R f) 
goal: Finsupp.total α' M R (v ∘ f) = Finsupp.total α M R v ∘ₗ Finsupp.lmapDomain R R f

full_name: Finsupp.total_comapDomain
code: theorem total_comapDomain (f : α → α') (l : α' →₀ R) (hf : Set.InjOn f (f ⁻¹' ↑l.support)) :
    Finsupp.total α M R v (Finsupp.comapDomain f l hf) =
      (l.support.preimage f hf).sum fun i => l (f i) • v i 
goal: (Finsupp.total α M R v) (Finsupp.comapDomain f l hf) = ∑ i ∈ l.support.preimage f hf, l (f i) • v i

full_name: Finsupp.total_onFinset
code: theorem total_onFinset {s : Finset α} {f : α → R} (g : α → M) (hf : ∀ a, f a ≠ 0 → a ∈ s) :
    Finsupp.total α M R g (Finsupp.onFinset s f hf) = Finset.sum s fun x : α => f x • g x 
goal: (Finsupp.total α M R g) (Finsupp.onFinset s f hf) = ∑ x ∈ s, f x • g x

full_name: Finsupp.domLCongr
code: /-- An equivalence of domains induces a linear equivalence of finitely supported functions.

This is `Finsupp.domCongr` as a `LinearEquiv`.
See also `LinearMap.funCongrLeft` for the case of arbitrary functions. -/
protected def domLCongr {α₁ α₂ : Type*} (e : α₁ ≃ α₂) : (α₁ →₀ M) ≃ₗ[R] α₂ →₀ M 
goal: (α₁ →₀ M) ≃ₗ[R] α₂ →₀ M

full_name: Finsupp.domLCongr_apply
code: @[simp]
theorem domLCongr_apply {α₁ : Type*} {α₂ : Type*} (e : α₁ ≃ α₂) (v : α₁ →₀ M) :
    (Finsupp.domLCongr e : _ ≃ₗ[R] _) v = Finsupp.domCongr e v 
goal: (Finsupp.domLCongr e) v = (Finsupp.domCongr e) v

full_name: Finsupp.domLCongr_refl
code: @[simp]
theorem domLCongr_refl : Finsupp.domLCongr (Equiv.refl α) = LinearEquiv.refl R (α →₀ M) 
goal: Finsupp.domLCongr (Equiv.refl α) = LinearEquiv.refl R (α →₀ M)

full_name: Finsupp.domLCongr_trans
code: theorem domLCongr_trans {α₁ α₂ α₃ : Type*} (f : α₁ ≃ α₂) (f₂ : α₂ ≃ α₃) :
    (Finsupp.domLCongr f).trans (Finsupp.domLCongr f₂) =
      (Finsupp.domLCongr (f.trans f₂) : (_ →₀ M) ≃ₗ[R] _) 
goal: Finsupp.domLCongr f ≪≫ₗ Finsupp.domLCongr f₂ = Finsupp.domLCongr (f.trans f₂)

full_name: Finsupp.domLCongr_symm
code: @[simp]
theorem domLCongr_symm {α₁ α₂ : Type*} (f : α₁ ≃ α₂) :
    ((Finsupp.domLCongr f).symm : (_ →₀ M) ≃ₗ[R] _) = Finsupp.domLCongr f.symm 
goal: (Finsupp.domLCongr f).symm = Finsupp.domLCongr f.symm

full_name: Finsupp.domLCongr_single
code: theorem domLCongr_single {α₁ : Type*} {α₂ : Type*} (e : α₁ ≃ α₂) (i : α₁) (m : M) :
    (Finsupp.domLCongr e : _ ≃ₗ[R] _) (Finsupp.single i m) = Finsupp.single (e i) m 
goal: (Finsupp.domLCongr e) (Finsupp.single i m) = Finsupp.single (e i) m

full_name: Finsupp.congr
code: /-- An equivalence of sets induces a linear equivalence of `Finsupp`s supported on those sets. -/
noncomputable def congr {α' : Type*} (s : Set α) (t : Set α') (e : s ≃ t) :
    supported M R s ≃ₗ[R] supported M R t 
goal: ↥(Finsupp.supported M R s) ≃ₗ[R] ↥(Finsupp.supported M R t)

full_name: Finsupp.mapRange.linearMap
code: /-- `Finsupp.mapRange` as a `LinearMap`. -/
def mapRange.linearMap (f : M →ₗ[R] N) : (α →₀ M) →ₗ[R] α →₀ N 
goal: (α →₀ M) →ₗ[R] α →₀ N

full_name: Finsupp.mapRange.linearMap_apply
code: @[simp]
theorem mapRange.linearMap_apply (f : M →ₗ[R] N) (g : α →₀ M) :
    mapRange.linearMap f g = mapRange f f.map_zero g 
goal: (Finsupp.mapRange.linearMap f) g = Finsupp.mapRange ⇑f ⋯ g

full_name: Finsupp.mapRange.linearMap_id
code: @[simp]
theorem mapRange.linearMap_id :
    mapRange.linearMap LinearMap.id = (LinearMap.id : (α →₀ M) →ₗ[R] _) 
goal: Finsupp.mapRange.linearMap LinearMap.id = LinearMap.id

full_name: Finsupp.mapRange.linearMap_comp
code: theorem mapRange.linearMap_comp (f : N →ₗ[R] P) (f₂ : M →ₗ[R] N) :
    (mapRange.linearMap (f.comp f₂) : (α →₀ _) →ₗ[R] _) =
      (mapRange.linearMap f).comp (mapRange.linearMap f₂) 
goal: Finsupp.mapRange.linearMap (f ∘ₗ f₂) = Finsupp.mapRange.linearMap f ∘ₗ Finsupp.mapRange.linearMap f₂

full_name: Finsupp.mapRange.linearMap_toAddMonoidHom
code: @[simp]
theorem mapRange.linearMap_toAddMonoidHom (f : M →ₗ[R] N) :
    (mapRange.linearMap f).toAddMonoidHom =
      (mapRange.addMonoidHom f.toAddMonoidHom : (α →₀ M) →+ _) 
goal: (Finsupp.mapRange.linearMap f).toAddMonoidHom = Finsupp.mapRange.addMonoidHom f.toAddMonoidHom

full_name: Finsupp.mapRange.linearEquiv
code: /-- `Finsupp.mapRange` as a `LinearEquiv`. -/
def mapRange.linearEquiv (e : M ≃ₗ[R] N) : (α →₀ M) ≃ₗ[R] α →₀ N 
goal: (α →₀ M) ≃ₗ[R] α →₀ N

full_name: Finsupp.mapRange.linearEquiv_apply
code: @[simp]
theorem mapRange.linearEquiv_apply (e : M ≃ₗ[R] N) (g : α →₀ M) :
    mapRange.linearEquiv e g = mapRange.linearMap e.toLinearMap g 
goal: (Finsupp.mapRange.linearEquiv e) g = (Finsupp.mapRange.linearMap ↑e) g

full_name: Finsupp.mapRange.linearEquiv_refl
code: @[simp]
theorem mapRange.linearEquiv_refl :
    mapRange.linearEquiv (LinearEquiv.refl R M) = LinearEquiv.refl R (α →₀ M) 
goal: Finsupp.mapRange.linearEquiv (LinearEquiv.refl R M) = LinearEquiv.refl R (α →₀ M)

full_name: Finsupp.mapRange.linearEquiv_trans
code: theorem mapRange.linearEquiv_trans (f : M ≃ₗ[R] N) (f₂ : N ≃ₗ[R] P) :
    (mapRange.linearEquiv (f.trans f₂) : (α →₀ _) ≃ₗ[R] _) =
      (mapRange.linearEquiv f).trans (mapRange.linearEquiv f₂) 
goal: Finsupp.mapRange.linearEquiv (f ≪≫ₗ f₂) = Finsupp.mapRange.linearEquiv f ≪≫ₗ Finsupp.mapRange.linearEquiv f₂

full_name: Finsupp.mapRange.linearEquiv_symm
code: @[simp]
theorem mapRange.linearEquiv_symm (f : M ≃ₗ[R] N) :
    ((mapRange.linearEquiv f).symm : (α →₀ _) ≃ₗ[R] _) = mapRange.linearEquiv f.symm 
goal: (Finsupp.mapRange.linearEquiv f).symm = Finsupp.mapRange.linearEquiv f.symm

full_name: Finsupp.mapRange.linearEquiv_toAddEquiv
code: @[simp 1500]
theorem mapRange.linearEquiv_toAddEquiv (f : M ≃ₗ[R] N) :
    (mapRange.linearEquiv f).toAddEquiv = (mapRange.addEquiv f.toAddEquiv : (α →₀ M) ≃+ _) 
goal: (Finsupp.mapRange.linearEquiv f).toAddEquiv = Finsupp.mapRange.addEquiv f.toAddEquiv

full_name: Finsupp.mapRange.linearEquiv_toLinearMap
code: @[simp]
theorem mapRange.linearEquiv_toLinearMap (f : M ≃ₗ[R] N) :
    (mapRange.linearEquiv f).toLinearMap = (mapRange.linearMap f.toLinearMap : (α →₀ M) →ₗ[R] _) 
goal: ↑(Finsupp.mapRange.linearEquiv f) = Finsupp.mapRange.linearMap ↑f

full_name: Finsupp.lcongr
code: /-- An equivalence of domain and a linear equivalence of codomain induce a linear equivalence of the
corresponding finitely supported functions. -/
def lcongr {ι κ : Sort _} (e₁ : ι ≃ κ) (e₂ : M ≃ₗ[R] N) : (ι →₀ M) ≃ₗ[R] κ →₀ N 
goal: (ι →₀ M) ≃ₗ[R] κ →₀ N

full_name: Finsupp.lcongr_single
code: @[simp]
theorem lcongr_single {ι κ : Sort _} (e₁ : ι ≃ κ) (e₂ : M ≃ₗ[R] N) (i : ι) (m : M) :
    lcongr e₁ e₂ (Finsupp.single i m) = Finsupp.single (e₁ i) (e₂ m) 
goal: (Finsupp.lcongr e₁ e₂) (Finsupp.single i m) = Finsupp.single (e₁ i) (e₂ m)

full_name: Finsupp.lcongr_apply_apply
code: @[simp]
theorem lcongr_apply_apply {ι κ : Sort _} (e₁ : ι ≃ κ) (e₂ : M ≃ₗ[R] N) (f : ι →₀ M) (k : κ) :
    lcongr e₁ e₂ f k = e₂ (f (e₁.symm k)) 
goal: ((Finsupp.lcongr e₁ e₂) f) k = e₂ (f (e₁.symm k))

full_name: Finsupp.lcongr_symm_single
code: theorem lcongr_symm_single {ι κ : Sort _} (e₁ : ι ≃ κ) (e₂ : M ≃ₗ[R] N) (k : κ) (n : N) :
    (lcongr e₁ e₂).symm (Finsupp.single k n) = Finsupp.single (e₁.symm k) (e₂.symm n) 
goal: (Finsupp.lcongr e₁ e₂).symm (Finsupp.single k n) = Finsupp.single (e₁.symm k) (e₂.symm n)

full_name: Finsupp.lcongr_symm
code: @[simp]
theorem lcongr_symm {ι κ : Sort _} (e₁ : ι ≃ κ) (e₂ : M ≃ₗ[R] N) :
    (lcongr e₁ e₂).symm = lcongr e₁.symm e₂.symm 
goal: (Finsupp.lcongr e₁ e₂).symm = Finsupp.lcongr e₁.symm e₂.symm

full_name: Finsupp.sumFinsuppLEquivProdFinsupp
code: /-- The linear equivalence between `(α ⊕ β) →₀ M` and `(α →₀ M) × (β →₀ M)`.

This is the `LinearEquiv` version of `Finsupp.sumFinsuppEquivProdFinsupp`. -/
@[simps apply symm_apply]
def sumFinsuppLEquivProdFinsupp {α β : Type*} : (α ⊕ β →₀ M) ≃ₗ[R] (α →₀ M) × (β →₀ M) 
goal: (α ⊕ β →₀ M) ≃ₗ[R] (α →₀ M) × (β →₀ M)

full_name: Finsupp.sumFinsuppLEquivProdFinsupp_symm_apply
code: /-- The linear equivalence between `(α ⊕ β) →₀ M` and `(α →₀ M) × (β →₀ M)`.

This is the `LinearEquiv` version of `Finsupp.sumFinsuppEquivProdFinsupp`. -/
@[simps apply symm_apply]
def sumFinsuppLEquivProdFinsupp {α β : Type*} : (α ⊕ β →₀ M) ≃ₗ[R] (α →₀ M) × (β →₀ M) 
goal: ∀ (a : (α →₀ M) × (β →₀ M)),
  (Finsupp.sumFinsuppLEquivProdFinsupp R).symm a = Finsupp.sumFinsuppAddEquivProdFinsupp.invFun a

full_name: Finsupp.sumFinsuppLEquivProdFinsupp_apply
code: /-- The linear equivalence between `(α ⊕ β) →₀ M` and `(α →₀ M) × (β →₀ M)`.

This is the `LinearEquiv` version of `Finsupp.sumFinsuppEquivProdFinsupp`. -/
@[simps apply symm_apply]
def sumFinsuppLEquivProdFinsupp {α β : Type*} : (α ⊕ β →₀ M) ≃ₗ[R] (α →₀ M) × (β →₀ M) 
goal: ∀ (a : α ⊕ β →₀ M), (Finsupp.sumFinsuppLEquivProdFinsupp R) a = Finsupp.sumFinsuppAddEquivProdFinsupp.toFun a

full_name: Finsupp.fst_sumFinsuppLEquivProdFinsupp
code: theorem fst_sumFinsuppLEquivProdFinsupp {α β : Type*} (f : α ⊕ β →₀ M) (x : α) :
    (sumFinsuppLEquivProdFinsupp R f).1 x = f (Sum.inl x) 
goal: ((Finsupp.sumFinsuppLEquivProdFinsupp R) f).1 x = f (Sum.inl x)

full_name: Finsupp.snd_sumFinsuppLEquivProdFinsupp
code: theorem snd_sumFinsuppLEquivProdFinsupp {α β : Type*} (f : α ⊕ β →₀ M) (y : β) :
    (sumFinsuppLEquivProdFinsupp R f).2 y = f (Sum.inr y) 
goal: ((Finsupp.sumFinsuppLEquivProdFinsupp R) f).2 y = f (Sum.inr y)

full_name: Finsupp.sumFinsuppLEquivProdFinsupp_symm_inl
code: theorem sumFinsuppLEquivProdFinsupp_symm_inl {α β : Type*} (fg : (α →₀ M) × (β →₀ M)) (x : α) :
    ((sumFinsuppLEquivProdFinsupp R).symm fg) (Sum.inl x) = fg.1 x 
goal: ((Finsupp.sumFinsuppLEquivProdFinsupp R).symm fg) (Sum.inl x) = fg.1 x

full_name: Finsupp.sumFinsuppLEquivProdFinsupp_symm_inr
code: theorem sumFinsuppLEquivProdFinsupp_symm_inr {α β : Type*} (fg : (α →₀ M) × (β →₀ M)) (y : β) :
    ((sumFinsuppLEquivProdFinsupp R).symm fg) (Sum.inr y) = fg.2 y 
goal: ((Finsupp.sumFinsuppLEquivProdFinsupp R).symm fg) (Sum.inr y) = fg.2 y

full_name: Finsupp.sigmaFinsuppLEquivPiFinsupp
code: /-- On a `Fintype η`, `Finsupp.split` is a linear equivalence between
`(Σ (j : η), ιs j) →₀ M` and `(j : η) → (ιs j →₀ M)`.

This is the `LinearEquiv` version of `Finsupp.sigmaFinsuppAddEquivPiFinsupp`. -/
noncomputable def sigmaFinsuppLEquivPiFinsupp {M : Type*} {ιs : η → Type*} [AddCommMonoid M]
    [Module R M] : ((Σ j, ιs j) →₀ M) ≃ₗ[R] (j : _) → (ιs j →₀ M) 
goal: ((j : η) × ιs j →₀ M) ≃ₗ[R] (j : η) → ιs j →₀ M

full_name: Finsupp.sigmaFinsuppLEquivPiFinsupp_apply
code: @[simp]
theorem sigmaFinsuppLEquivPiFinsupp_apply {M : Type*} {ιs : η → Type*} [AddCommMonoid M]
    [Module R M] (f : (Σj, ιs j) →₀ M) (j i) : sigmaFinsuppLEquivPiFinsupp R f j i = f ⟨j, i⟩ 
goal: ((Finsupp.sigmaFinsuppLEquivPiFinsupp R) f j) i = f ⟨j, i⟩

full_name: Finsupp.sigmaFinsuppLEquivPiFinsupp_symm_apply
code: @[simp]
theorem sigmaFinsuppLEquivPiFinsupp_symm_apply {M : Type*} {ιs : η → Type*} [AddCommMonoid M]
    [Module R M] (f : (j : _) → (ιs j →₀ M)) (ji) :
    (Finsupp.sigmaFinsuppLEquivPiFinsupp R).symm f ji = f ji.1 ji.2 
goal: ((Finsupp.sigmaFinsuppLEquivPiFinsupp R).symm f) ji = (f ji.fst) ji.snd

full_name: Finsupp.finsuppProdLEquiv
code: /-- The linear equivalence between `α × β →₀ M` and `α →₀ β →₀ M`.

This is the `LinearEquiv` version of `Finsupp.finsuppProdEquiv`. -/
noncomputable def finsuppProdLEquiv {α β : Type*} (R : Type*) {M : Type*} [Semiring R]
    [AddCommMonoid M] [Module R M] : (α × β →₀ M) ≃ₗ[R] α →₀ β →₀ M 
goal: (α × β →₀ M) ≃ₗ[R] α →₀ β →₀ M

full_name: Finsupp.finsuppProdLEquiv_apply
code: @[simp]
theorem finsuppProdLEquiv_apply {α β R M : Type*} [Semiring R] [AddCommMonoid M] [Module R M]
    (f : α × β →₀ M) (x y) : finsuppProdLEquiv R f x y = f (x, y) 
goal: (((Finsupp.finsuppProdLEquiv R) f) x) y = f (x, y)

full_name: Finsupp.finsuppProdLEquiv_symm_apply
code: @[simp]
theorem finsuppProdLEquiv_symm_apply {α β R M : Type*} [Semiring R] [AddCommMonoid M] [Module R M]
    (f : α →₀ β →₀ M) (xy) : (finsuppProdLEquiv R).symm f xy = f xy.1 xy.2 
goal: ((Finsupp.finsuppProdLEquiv R).symm f) xy = (f xy.1) xy.2

full_name: Finsupp.instCountableSubtypeMemSubmoduleSpanRange
code: /-- If `R` is countable, then any `R`-submodule spanned by a countable family of vectors is
countable. -/
instance {ι : Type*} [Countable R] [Countable ι] (v : ι → M) :
    Countable (Submodule.span R (Set.range v)) 
goal: Countable ↥(Submodule.span R (Set.range v))

full_name: Fintype.total
code: /-- `Fintype.total R S v f` is the linear combination of vectors in `v` with weights in `f`.
This variant of `Finsupp.total` is defined on fintype indexed vectors.

This map is linear in `v` if `R` is commutative, and always linear in `f`.
See note [bundled maps over different rings] for why separate `R` and `S` semirings are used.
-/
protected def Fintype.total : (α → M) →ₗ[S] (α → R) →ₗ[R] M 
goal: (α → M) →ₗ[S] (α → R) →ₗ[R] M

full_name: Fintype.total_apply
code: theorem Fintype.total_apply (f) : Fintype.total R S v f = ∑ i, f i • v i 
goal: ((Fintype.total R S) v) f = ∑ i : α, f i • v i

full_name: Fintype.total_apply_single
code: @[simp]
theorem Fintype.total_apply_single [DecidableEq α] (i : α) (r : R) :
    Fintype.total R S v (Pi.single i r) = r • v i 
goal: ((Fintype.total R S) v) (Pi.single i r) = r • v i

full_name: Finsupp.total_eq_fintype_total_apply
code: theorem Finsupp.total_eq_fintype_total_apply (x : α → R) : Finsupp.total α M R v
    ((Finsupp.linearEquivFunOnFinite R R α).symm x) = Fintype.total R S v x 
goal: (Finsupp.total α M R v) ((Finsupp.linearEquivFunOnFinite R R α).symm x) = ((Fintype.total R S) v) x

full_name: Finsupp.total_eq_fintype_total
code: theorem Finsupp.total_eq_fintype_total :
    (Finsupp.total α M R v).comp (Finsupp.linearEquivFunOnFinite R R α).symm.toLinearMap =
      Fintype.total R S v 
goal: Finsupp.total α M R v ∘ₗ ↑(Finsupp.linearEquivFunOnFinite R R α).symm = (Fintype.total R S) v

full_name: Fintype.range_total
code: @[simp]
theorem Fintype.range_total :
    LinearMap.range (Fintype.total R S v) = Submodule.span R (Set.range v) 
goal: LinearMap.range ((Fintype.total R S) v) = Submodule.span R (Set.range v)

full_name: mem_span_range_iff_exists_fun
code: /-- An element `x` lies in the span of `v` iff it can be written as sum `∑ cᵢ • vᵢ = x`.
-/
theorem mem_span_range_iff_exists_fun :
    x ∈ span R (range v) ↔ ∃ c : α → R, ∑ i, c i • v i = x 
goal: x ∈ Submodule.span R (Set.range v) ↔ ∃ c, ∑ i : α, c i • v i = x

full_name: top_le_span_range_iff_forall_exists_fun
code: /-- A family `v : α → V` is generating `V` iff every element `(x : V)`
can be written as sum `∑ cᵢ • vᵢ = x`.
-/
theorem top_le_span_range_iff_forall_exists_fun :
    ⊤ ≤ span R (range v) ↔ ∀ x, ∃ c : α → R, ∑ i, c i • v i = x 
goal: ⊤ ≤ Submodule.span R (Set.range v) ↔ ∀ (x : M), ∃ c, ∑ i : α, c i • v i = x

full_name: Span.repr_def
code: /-- Pick some representation of `x : span R w` as a linear combination in `w`,
using the axiom of choice.
-/
irreducible_def Span.repr (w : Set M) (x : span R w) : w →₀ R 
goal: Span.repr R w x = ⋯.choose

full_name: Span.repr
code: /-- Pick some representation of `x : span R w` as a linear combination in `w`,
using the axiom of choice.
-/
irreducible_def Span.repr (w : Set M) (x : span R w) : w →₀ R 
goal: ↑w →₀ R

full_name: definition._@.Mathlib.LinearAlgebra.Finsupp._hyg.16827
code: /-- Pick some representation of `x : span R w` as a linear combination in `w`,
using the axiom of choice.
-/
irreducible_def Span.repr (w : Set M) (x : span R w) : w →₀ R 
goal: ↑w →₀ R

full_name: wrapped._@.Mathlib.LinearAlgebra.Finsupp._hyg.16827
code: /-- Pick some representation of `x : span R w` as a linear combination in `w`,
using the axiom of choice.
-/
irreducible_def Span.repr (w : Set M) (x : span R w) : w →₀ R 
goal: Subtype (Eq definition✝)

full_name: Span.finsupp_total_repr
code: @[simp]
theorem Span.finsupp_total_repr {w : Set M} (x : span R w) :
    Finsupp.total w M R (↑) (Span.repr R w x) = x 
goal: (Finsupp.total (↑w) M R Subtype.val) (Span.repr R w x) = ↑x

full_name: Submodule.finsupp_sum_mem
code: protected theorem Submodule.finsupp_sum_mem {ι β : Type*} [Zero β] (S : Submodule R M) (f : ι →₀ β)
    (g : ι → β → M) (h : ∀ c, f c ≠ 0 → g c (f c) ∈ S) : f.sum g ∈ S 
goal: f.sum g ∈ S

full_name: LinearMap.map_finsupp_total
code: theorem LinearMap.map_finsupp_total (f : M →ₗ[R] N) {ι : Type*} {g : ι → M} (l : ι →₀ R) :
    f (Finsupp.total ι M R g l) = Finsupp.total ι N R (f ∘ g) l 
goal: f ((Finsupp.total ι M R g) l) = (Finsupp.total ι N R (⇑f ∘ g)) l

full_name: Submodule.exists_finset_of_mem_iSup
code: theorem Submodule.exists_finset_of_mem_iSup {ι : Sort _} (p : ι → Submodule R M) {m : M}
    (hm : m ∈ ⨆ i, p i) : ∃ s : Finset ι, m ∈ ⨆ i ∈ s, p i 
goal: ∃ s, m ∈ ⨆ i ∈ s, p i

full_name: Submodule.mem_iSup_iff_exists_finset
code: /-- `Submodule.exists_finset_of_mem_iSup` as an `iff` -/
theorem Submodule.mem_iSup_iff_exists_finset {ι : Sort _} {p : ι → Submodule R M} {m : M} :
    (m ∈ ⨆ i, p i) ↔ ∃ s : Finset ι, m ∈ ⨆ i ∈ s, p i 
goal: m ∈ ⨆ i, p i ↔ ∃ s, m ∈ ⨆ i ∈ s, p i

full_name: Submodule.mem_sSup_iff_exists_finset
code: theorem Submodule.mem_sSup_iff_exists_finset {S : Set (Submodule R M)} {m : M} :
    m ∈ sSup S ↔ ∃ s : Finset (Submodule R M), ↑s ⊆ S ∧ m ∈ ⨆ i ∈ s, i 
goal: m ∈ sSup S ↔ ∃ s, ↑s ⊆ S ∧ m ∈ ⨆ i ∈ s, i

full_name: mem_span_finset
code: theorem mem_span_finset {s : Finset M} {x : M} :
    x ∈ span R (↑s : Set M) ↔ ∃ f : M → R, ∑ i ∈ s, f i • i = x 
goal: x ∈ Submodule.span R ↑s ↔ ∃ f, ∑ i ∈ s, f i • i = x

full_name: mem_span_set
code: /-- An element `m ∈ M` is contained in the `R`-submodule spanned by a set `s ⊆ M`, if and only if
`m` can be written as a finite `R`-linear combination of elements of `s`.
The implementation uses `Finsupp.sum`. -/
theorem mem_span_set {m : M} {s : Set M} :
    m ∈ Submodule.span R s ↔
      ∃ c : M →₀ R, (c.support : Set M) ⊆ s ∧ (c.sum fun mi r => r • mi) = m 
goal: m ∈ Submodule.span R s ↔ ∃ c, ↑c.support ⊆ s ∧ (c.sum fun mi r => r • mi) = m

full_name: mem_span_set'
code: /-- An element `m ∈ M` is contained in the `R`-submodule spanned by a set `s ⊆ M`, if and only if
`m` can be written as a finite `R`-linear combination of elements of `s`.
The implementation uses a sum indexed by `Fin n` for some `n`. -/
lemma mem_span_set' {m : M} {s : Set M} :
    m ∈ Submodule.span R s ↔ ∃ (n : ℕ) (f : Fin n → R) (g : Fin n → s),
      ∑ i, f i • (g i : M) = m 
goal: m ∈ Submodule.span R s ↔ ∃ n f g, ∑ i : Fin n, f i • ↑(g i) = m

full_name: span_eq_iUnion_nat
code: /-- The span of a subset `s` is the union over all `n` of the set of linear combinations of at most
`n` terms belonging to `s`. -/
lemma span_eq_iUnion_nat (s : Set M) :
    (Submodule.span R s : Set M) = ⋃ (n : ℕ),
      (fun (f : Fin n → (R × M)) ↦ ∑ i, (f i).1 • (f i).2) '' ({f | ∀ i, (f i).2 ∈ s}) 
goal: ↑(Submodule.span R s) = ⋃ n, (fun f => ∑ i : Fin n, (f i).1 • (f i).2) '' {f | ∀ (i : Fin n), (f i).2 ∈ s}

full_name: Module.subsingletonEquiv
code: /-- If `Subsingleton R`, then `M ≃ₗ[R] ι →₀ R` for any type `ι`. -/
@[simps]
def Module.subsingletonEquiv (R M ι : Type*) [Semiring R] [Subsingleton R] [AddCommMonoid M]
    [Module R M] : M ≃ₗ[R] ι →₀ R 
goal: M ≃ₗ[R] ι →₀ R

full_name: Module.subsingletonEquiv_symm_apply
code: /-- If `Subsingleton R`, then `M ≃ₗ[R] ι →₀ R` for any type `ι`. -/
@[simps]
def Module.subsingletonEquiv (R M ι : Type*) [Semiring R] [Subsingleton R] [AddCommMonoid M]
    [Module R M] : M ≃ₗ[R] ι →₀ R 
goal: ∀ (x : ι →₀ R), (Module.subsingletonEquiv R M ι).symm x = 0

full_name: Module.subsingletonEquiv_apply
code: /-- If `Subsingleton R`, then `M ≃ₗ[R] ι →₀ R` for any type `ι`. -/
@[simps]
def Module.subsingletonEquiv (R M ι : Type*) [Semiring R] [Subsingleton R] [AddCommMonoid M]
    [Module R M] : M ≃ₗ[R] ι →₀ R 
goal: ∀ (x : M), (Module.subsingletonEquiv R M ι) x = 0

full_name: LinearMap.splittingOfFinsuppSurjective
code: /-- A surjective linear map to finitely supported functions has a splitting. -/
def splittingOfFinsuppSurjective (f : M →ₗ[R] α →₀ R) (s : Surjective f) : (α →₀ R) →ₗ[R] M 
goal: (α →₀ R) →ₗ[R] M

full_name: LinearMap.splittingOfFinsuppSurjective_splits
code: theorem splittingOfFinsuppSurjective_splits (f : M →ₗ[R] α →₀ R) (s : Surjective f) :
    f.comp (splittingOfFinsuppSurjective f s) = LinearMap.id 
goal: f ∘ₗ f.splittingOfFinsuppSurjective s = LinearMap.id

full_name: LinearMap.leftInverse_splittingOfFinsuppSurjective
code: theorem leftInverse_splittingOfFinsuppSurjective (f : M →ₗ[R] α →₀ R) (s : Surjective f) :
    LeftInverse f (splittingOfFinsuppSurjective f s) 
goal: Function.LeftInverse ⇑f ⇑(f.splittingOfFinsuppSurjective s)

full_name: LinearMap.splittingOfFinsuppSurjective_injective
code: theorem splittingOfFinsuppSurjective_injective (f : M →ₗ[R] α →₀ R) (s : Surjective f) :
    Injective (splittingOfFinsuppSurjective f s) 
goal: Function.Injective ⇑(f.splittingOfFinsuppSurjective s)

full_name: LinearMap.splittingOfFunOnFintypeSurjective
code: /-- A surjective linear map to functions on a finite type has a splitting. -/
def splittingOfFunOnFintypeSurjective [Finite α] (f : M →ₗ[R] α → R) (s : Surjective f) :
    (α → R) →ₗ[R] M 
goal: (α → R) →ₗ[R] M

full_name: LinearMap.splittingOfFunOnFintypeSurjective_splits
code: theorem splittingOfFunOnFintypeSurjective_splits [Finite α] (f : M →ₗ[R] α → R)
    (s : Surjective f) : f.comp (splittingOfFunOnFintypeSurjective f s) = LinearMap.id 
goal: f ∘ₗ f.splittingOfFunOnFintypeSurjective s = LinearMap.id

full_name: LinearMap.leftInverse_splittingOfFunOnFintypeSurjective
code: theorem leftInverse_splittingOfFunOnFintypeSurjective [Finite α] (f : M →ₗ[R] α → R)
    (s : Surjective f) : LeftInverse f (splittingOfFunOnFintypeSurjective f s) 
goal: Function.LeftInverse ⇑f ⇑(f.splittingOfFunOnFintypeSurjective s)

full_name: LinearMap.splittingOfFunOnFintypeSurjective_injective
code: theorem splittingOfFunOnFintypeSurjective_injective [Finite α] (f : M →ₗ[R] α → R)
    (s : Surjective f) : Injective (splittingOfFunOnFintypeSurjective f s) 
goal: Function.Injective ⇑(f.splittingOfFunOnFintypeSurjective s)

full_name: LinearMap.coe_finsupp_sum
code: theorem coe_finsupp_sum (t : ι →₀ γ) (g : ι → γ → M →ₛₗ[σ₁₂] M₂) :
    ⇑(t.sum g) = t.sum fun i d => g i d 
goal: ⇑(t.sum g) = ⇑(t.sum fun i d => g i d)

full_name: LinearMap.finsupp_sum_apply
code: @[simp]
theorem finsupp_sum_apply (t : ι →₀ γ) (g : ι → γ → M →ₛₗ[σ₁₂] M₂) (b : M) :
    (t.sum g) b = t.sum fun i d => g i d b 
goal: (t.sum g) b = t.sum fun i d => (g i d) b

full_name: Submodule.mulLeftMap
code: /-- If `M` and `N` are submodules of an `R`-algebra `S`, `m : ι → M` is a family of elements, then
there is an `R`-linear map from `ι →₀ N` to `S` which maps `{ n_i }` to the sum of `m_i * n_i`.
This is used in the definition of linearly disjointness. -/
def mulLeftMap {M : Submodule R S} (N : Submodule R S) {ι : Type*} (m : ι → M) :
    (ι →₀ N) →ₗ[R] S 
goal: (ι →₀ ↥N) →ₗ[R] S

full_name: Submodule.mulLeftMap_apply
code: theorem mulLeftMap_apply {M N : Submodule R S} {ι : Type*} (m : ι → M) (n : ι →₀ N) :
    mulLeftMap N m n = Finsupp.sum n fun (i : ι) (n : N) ↦ (m i).1 * n.1 
goal: (Submodule.mulLeftMap N m) n = n.sum fun i n => ↑(m i) * ↑n

full_name: Submodule.mulLeftMap_apply_single
code: @[simp]
theorem mulLeftMap_apply_single {M N : Submodule R S} {ι : Type*} (m : ι → M) (i : ι) (n : N) :
    mulLeftMap N m (Finsupp.single i n) = (m i).1 * n.1 
goal: (Submodule.mulLeftMap N m) (Finsupp.single i n) = ↑(m i) * ↑n

full_name: Submodule.mulRightMap
code: /-- If `M` and `N` are submodules of an `R`-algebra `S`, `n : ι → N` is a family of elements, then
there is an `R`-linear map from `ι →₀ M` to `S` which maps `{ m_i }` to the sum of `m_i * n_i`.
This is used in the definition of linearly disjointness. -/
def mulRightMap (M : Submodule R S) {N : Submodule R S} {ι : Type*} (n : ι → N) :
    (ι →₀ M) →ₗ[R] S 
goal: (ι →₀ ↥M) →ₗ[R] S

full_name: Submodule.mulRightMap_apply
code: theorem mulRightMap_apply {M N : Submodule R S} {ι : Type*} (n : ι → N) (m : ι →₀ M) :
    mulRightMap M n m = Finsupp.sum m fun (i : ι) (m : M) ↦ m.1 * (n i).1 
goal: (M.mulRightMap n) m = m.sum fun i m => ↑m * ↑(n i)

full_name: Submodule.mulRightMap_apply_single
code: @[simp]
theorem mulRightMap_apply_single {M N : Submodule R S} {ι : Type*} (n : ι → N) (i : ι) (m : M) :
    mulRightMap M n (Finsupp.single i m) = m.1 * (n i).1 
goal: (M.mulRightMap n) (Finsupp.single i m) = ↑m * ↑(n i)

full_name: Submodule.mulLeftMap_eq_mulRightMap_of_commute
code: theorem mulLeftMap_eq_mulRightMap_of_commute
    {M : Submodule R S} (N : Submodule R S) {ι : Type*} (m : ι → M)
    (hc : ∀ (i : ι) (n : N), Commute (m i).1 n.1) : mulLeftMap N m = mulRightMap N m 
goal: Submodule.mulLeftMap N m = N.mulRightMap m

full_name: Submodule.mulLeftMap_eq_mulRightMap
code: theorem mulLeftMap_eq_mulRightMap {S : Type*} [CommSemiring S] [Module R S] [SMulCommClass R R S]
    [SMulCommClass R S S] [IsScalarTower R S S] {M : Submodule R S} (N : Submodule R S)
    {ι : Type*} (m : ι → M) : mulLeftMap N m = mulRightMap N m 
goal: Submodule.mulLeftMap N m = N.mulRightMap m