File: Mathlib/LinearAlgebra/DFinsupp.lean

full_name: DFinsupp.lmk
code: /-- `DFinsupp.mk` as a `LinearMap`. -/
def lmk (s : Finset ι) : (∀ i : (↑s : Set ι), M i) →ₗ[R] Π₀ i, M i 
goal: ((i : ↑↑s) → M ↑i) →ₗ[R] Π₀ (i : ι), M i

full_name: DFinsupp.lsingle
code: /-- `DFinsupp.single` as a `LinearMap` -/
def lsingle (i) : M i →ₗ[R] Π₀ i, M i 
goal: M i →ₗ[R] Π₀ (i : ι), M i

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

full_name: DFinsupp.lhom_ext'
code: /-- Two `R`-linear maps from `Π₀ i, M i` which agree on each `single i x` agree everywhere.

See note [partially-applied ext lemmas].
After apply this lemma, if `M = R` then it suffices to verify `φ (single a 1) = ψ (single a 1)`. -/
@[ext 1100]
theorem lhom_ext' ⦃φ ψ : (Π₀ i, M i) →ₗ[R] N⦄ (h : ∀ i, φ.comp (lsingle i) = ψ.comp (lsingle i)) :
    φ = ψ 
goal: φ = ψ

full_name: DFinsupp.lapply
code: /-- Interpret `fun (f : Π₀ i, M i) ↦ f i` as a linear map. -/
def lapply (i : ι) : (Π₀ i, M i) →ₗ[R] M i 
goal: (Π₀ (i : ι), M i) →ₗ[R] M i

full_name: DFinsupp.lmk_apply
code: @[simp, nolint simpNF]
theorem lmk_apply (s : Finset ι) (x) : (lmk s : _ →ₗ[R] Π₀ i, M i) x = mk s x 
goal: (DFinsupp.lmk s) x = DFinsupp.mk s x

full_name: DFinsupp.lsingle_apply
code: @[simp]
theorem lsingle_apply (i : ι) (x : M i) : (lsingle i : (M i) →ₗ[R] _) x = single i x 
goal: (DFinsupp.lsingle i) x = DFinsupp.single i x

full_name: DFinsupp.lapply_apply
code: @[simp]
theorem lapply_apply (i : ι) (f : Π₀ i, M i) : (lapply i : (Π₀ i, M i) →ₗ[R] _) f = f i 
goal: (DFinsupp.lapply i) f = f i

full_name: DFinsupp.addCommMonoidOfLinearMap
code: /-- Typeclass inference can't find `DFinsupp.addCommMonoid` without help for this case.
This instance allows it to be found where it is needed on the LHS of the colon in
`DFinsupp.moduleOfLinearMap`. -/
instance addCommMonoidOfLinearMap : AddCommMonoid (Π₀ i : ι, M i →ₗ[R] N) 
goal: AddCommMonoid (Π₀ (i : ι), M i →ₗ[R] N)

full_name: DFinsupp.moduleOfLinearMap
code: /-- Typeclass inference can't find `DFinsupp.module` without help for this case.
This is needed to define `DFinsupp.lsum` below.

The cause seems to be an inability to unify the `∀ i, AddCommMonoid (M i →ₗ[R] N)` instance that
we have with the `∀ i, Zero (M i →ₗ[R] N)` instance which appears as a parameter to the
`DFinsupp` type. -/
instance moduleOfLinearMap [Semiring S] [Module S N] [SMulCommClass R S N] :
    Module S (Π₀ i : ι, M i →ₗ[R] N) 
goal: Module S (Π₀ (i : ι), M i →ₗ[R] N)

full_name: DFinsupp.instEquivLikeLinearEquiv
code: instance {R : Type*} {S : Type*} [Semiring R] [Semiring S] (σ : R →+* S)
    {σ' : S →+* R} [RingHomInvPair σ σ'] [RingHomInvPair σ' σ] (M : Type*) (M₂ : Type*)
    [AddCommMonoid M] [AddCommMonoid M₂] [Module R M] [Module S M₂] :
    EquivLike (LinearEquiv σ M M₂) M M₂ 
goal: EquivLike (M ≃ₛₗ[σ] M₂) M M₂

full_name: DFinsupp.lsum_apply_apply
code: /-- The `DFinsupp` version of `Finsupp.lsum`.

See note [bundled maps over different rings] for why separate `R` and `S` semirings are used. -/
@[simps]
def lsum [Semiring S] [Module S N] [SMulCommClass R S N] :
    (∀ i, M i →ₗ[R] N) ≃ₗ[S] (Π₀ i, M i) →ₗ[R] N 
goal: ((DFinsupp.lsum S) F) a = (DFinsupp.sumAddHom fun i => (F i).toAddMonoidHom) a

full_name: DFinsupp.lsum_symm_apply
code: /-- The `DFinsupp` version of `Finsupp.lsum`.

See note [bundled maps over different rings] for why separate `R` and `S` semirings are used. -/
@[simps]
def lsum [Semiring S] [Module S N] [SMulCommClass R S N] :
    (∀ i, M i →ₗ[R] N) ≃ₗ[S] (Π₀ i, M i) →ₗ[R] N 
goal: (DFinsupp.lsum S).symm F i = F ∘ₗ DFinsupp.lsingle i

full_name: DFinsupp.lsum
code: /-- The `DFinsupp` version of `Finsupp.lsum`.

See note [bundled maps over different rings] for why separate `R` and `S` semirings are used. -/
@[simps]
def lsum [Semiring S] [Module S N] [SMulCommClass R S N] :
    (∀ i, M i →ₗ[R] N) ≃ₗ[S] (Π₀ i, M i) →ₗ[R] N 
goal: ((i : ι) → M i →ₗ[R] N) ≃ₗ[S] (Π₀ (i : ι), M i) →ₗ[R] N

full_name: DFinsupp.lsum_single
code: /-- While `simp` can prove this, it is often convenient to avoid unfolding `lsum` into `sumAddHom`
with `DFinsupp.lsum_apply_apply`. -/
theorem lsum_single [Semiring S] [Module S N] [SMulCommClass R S N] (F : ∀ i, M i →ₗ[R] N) (i)
    (x : M i) : lsum S (M := M) F (single i x) = F i x 
goal: ((DFinsupp.lsum S) F) (DFinsupp.single i x) = (F i) x

full_name: DFinsupp.mapRange_smul
code: theorem mapRange_smul (f : ∀ i, β₁ i → β₂ i) (hf : ∀ i, f i 0 = 0) (r : R)
    (hf' : ∀ i x, f i (r • x) = r • f i x) (g : Π₀ i, β₁ i) :
    mapRange f hf (r • g) = r • mapRange f hf g 
goal: DFinsupp.mapRange f hf (r • g) = r • DFinsupp.mapRange f hf g

full_name: DFinsupp.mapRange.linearMap_apply
code: /-- `DFinsupp.mapRange` as a `LinearMap`. -/
@[simps! apply]
def mapRange.linearMap (f : ∀ i, β₁ i →ₗ[R] β₂ i) : (Π₀ i, β₁ i) →ₗ[R] Π₀ i, β₂ i 
goal: (DFinsupp.mapRange.linearMap f) x = DFinsupp.mapRange (fun i x => (f i) x) ⋯ x

full_name: DFinsupp.mapRange.linearMap
code: /-- `DFinsupp.mapRange` as a `LinearMap`. -/
@[simps! apply]
def mapRange.linearMap (f : ∀ i, β₁ i →ₗ[R] β₂ i) : (Π₀ i, β₁ i) →ₗ[R] Π₀ i, β₂ i 
goal: (Π₀ (i : ι), β₁ i) →ₗ[R] Π₀ (i : ι), β₂ i

full_name: DFinsupp.mapRange.linearMap_id
code: @[simp]
theorem mapRange.linearMap_id :
    (mapRange.linearMap fun i => (LinearMap.id : β₂ i →ₗ[R] _)) = LinearMap.id 
goal: (DFinsupp.mapRange.linearMap fun i => LinearMap.id) = LinearMap.id

full_name: DFinsupp.mapRange.linearMap_comp
code: theorem mapRange.linearMap_comp (f : ∀ i, β₁ i →ₗ[R] β₂ i) (f₂ : ∀ i, β i →ₗ[R] β₁ i) :
    (mapRange.linearMap fun i => (f i).comp (f₂ i)) =
      (mapRange.linearMap f).comp (mapRange.linearMap f₂) 
goal: (DFinsupp.mapRange.linearMap fun i => f i ∘ₗ f₂ i) = DFinsupp.mapRange.linearMap f ∘ₗ DFinsupp.mapRange.linearMap f₂

full_name: DFinsupp.sum_mapRange_index.linearMap
code: theorem sum_mapRange_index.linearMap [DecidableEq ι] {f : ∀ i, β₁ i →ₗ[R] β₂ i}
    {h : ∀ i, β₂ i →ₗ[R] N} {l : Π₀ i, β₁ i} :
    DFinsupp.lsum ℕ h (mapRange.linearMap f l) = DFinsupp.lsum ℕ (fun i => (h i).comp (f i)) l 
goal: ((DFinsupp.lsum ℕ) h) ((DFinsupp.mapRange.linearMap f) l) = ((DFinsupp.lsum ℕ) fun i => h i ∘ₗ f i) l

full_name: DFinsupp.mapRange.linearEquiv_apply
code: /-- `DFinsupp.mapRange.linearMap` as a `LinearEquiv`. -/
@[simps apply]
def mapRange.linearEquiv (e : ∀ i, β₁ i ≃ₗ[R] β₂ i) : (Π₀ i, β₁ i) ≃ₗ[R] Π₀ i, β₂ i 
goal: (DFinsupp.mapRange.linearEquiv e) x = DFinsupp.mapRange (fun i x => (e i) x) ⋯ x

full_name: DFinsupp.mapRange.linearEquiv
code: /-- `DFinsupp.mapRange.linearMap` as a `LinearEquiv`. -/
@[simps apply]
def mapRange.linearEquiv (e : ∀ i, β₁ i ≃ₗ[R] β₂ i) : (Π₀ i, β₁ i) ≃ₗ[R] Π₀ i, β₂ i 
goal: (Π₀ (i : ι), β₁ i) ≃ₗ[R] Π₀ (i : ι), β₂ i

full_name: DFinsupp.mapRange.linearEquiv_refl
code: @[simp]
theorem mapRange.linearEquiv_refl :
    (mapRange.linearEquiv fun i => LinearEquiv.refl R (β₁ i)) = LinearEquiv.refl _ _ 
goal: (DFinsupp.mapRange.linearEquiv fun i => LinearEquiv.refl R (β₁ i)) = LinearEquiv.refl R (Π₀ (i : ι), β₁ i)

full_name: DFinsupp.mapRange.linearEquiv_trans
code: theorem mapRange.linearEquiv_trans (f : ∀ i, β i ≃ₗ[R] β₁ i) (f₂ : ∀ i, β₁ i ≃ₗ[R] β₂ i) :
    (mapRange.linearEquiv fun i => (f i).trans (f₂ i)) =
      (mapRange.linearEquiv f).trans (mapRange.linearEquiv f₂) 
goal: (DFinsupp.mapRange.linearEquiv fun i => f i ≪≫ₗ f₂ i) =
  DFinsupp.mapRange.linearEquiv f ≪≫ₗ DFinsupp.mapRange.linearEquiv f₂

full_name: DFinsupp.mapRange.linearEquiv_symm
code: @[simp]
theorem mapRange.linearEquiv_symm (e : ∀ i, β₁ i ≃ₗ[R] β₂ i) :
    (mapRange.linearEquiv e).symm = mapRange.linearEquiv fun i => (e i).symm 
goal: (DFinsupp.mapRange.linearEquiv e).symm = DFinsupp.mapRange.linearEquiv fun i => (e i).symm

full_name: DFinsupp.coprodMap
code: /-- Given a family of linear maps `f i : M i →ₗ[R] N`, we can form a linear map
`(Π₀ i, M i) →ₗ[R] N` which sends `x : Π₀ i, M i` to the sum over `i` of `f i` applied to `x i`.
This is the map coming from the universal property of `Π₀ i, M i` as the coproduct of the `M i`.
See also `LinearMap.coprod` for the binary product version. -/
def coprodMap (f : ∀ i : ι, M i →ₗ[R] N) : (Π₀ i, M i) →ₗ[R] N 
goal: (Π₀ (i : ι), M i) →ₗ[R] N

full_name: DFinsupp.coprodMap_apply
code: theorem coprodMap_apply (f : ∀ i : ι, M i →ₗ[R] N) (x : Π₀ i, M i) :
    coprodMap f x =
      DFinsupp.sum (mapRange (fun i => f i) (fun _ => LinearMap.map_zero _) x) fun _ =>
        id 
goal: (DFinsupp.coprodMap f) x = (DFinsupp.mapRange (fun i => ⇑(f i)) ⋯ x).sum fun x => id

full_name: DFinsupp.coprodMap_apply_single
code: theorem coprodMap_apply_single (f : ∀ i : ι, M i →ₗ[R] N) (i : ι) (x : M i) :
    coprodMap f (single i x) = f i x 
goal: (DFinsupp.coprodMap f) (DFinsupp.single i x) = (f i) x

full_name: Submodule.dfinsupp_sum_mem
code: theorem dfinsupp_sum_mem {β : ι → Type*} [∀ i, Zero (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)]
    (S : Submodule R N) (f : Π₀ i, β i) (g : ∀ i, β i → N) (h : ∀ c, f c ≠ 0 → g c (f c) ∈ S) :
    f.sum g ∈ S 
goal: f.sum g ∈ S

full_name: Submodule.dfinsupp_sumAddHom_mem
code: theorem dfinsupp_sumAddHom_mem {β : ι → Type*} [∀ i, AddZeroClass (β i)] (S : Submodule R N)
    (f : Π₀ i, β i) (g : ∀ i, β i →+ N) (h : ∀ c, f c ≠ 0 → g c (f c) ∈ S) :
    DFinsupp.sumAddHom g f ∈ S 
goal: (DFinsupp.sumAddHom g) f ∈ S

full_name: Submodule.iSup_eq_range_dfinsupp_lsum
code: /-- The supremum of a family of submodules is equal to the range of `DFinsupp.lsum`; that is
every element in the `iSup` can be produced from taking a finite number of non-zero elements
of `p i`, coercing them to `N`, and summing them. -/
theorem iSup_eq_range_dfinsupp_lsum (p : ι → Submodule R N) :
    iSup p = LinearMap.range (DFinsupp.lsum ℕ (M := fun i ↦ ↥(p i)) fun i => (p i).subtype) 
goal: iSup p = LinearMap.range ((DFinsupp.lsum ℕ) fun i => (p i).subtype)

full_name: Submodule.biSup_eq_range_dfinsupp_lsum
code: /-- The bounded supremum of a family of commutative additive submonoids is equal to the range of
`DFinsupp.sumAddHom` composed with `DFinsupp.filter_add_monoid_hom`; 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 biSup_eq_range_dfinsupp_lsum (p : ι → Prop) [DecidablePred p] (S : ι → Submodule R N) :
    ⨆ (i) (_ : p i), S i =
      LinearMap.range
        (LinearMap.comp
          (DFinsupp.lsum ℕ (M := fun i ↦ ↥(S i)) (fun i => (S i).subtype))
            (DFinsupp.filterLinearMap R _ p)) 
goal: ⨆ i, ⨆ (_ : p i), S i =
  LinearMap.range (((DFinsupp.lsum ℕ) fun i => (S i).subtype) ∘ₗ DFinsupp.filterLinearMap R (fun i => ↥(S i)) p)

full_name: Submodule.mem_iSup_iff_exists_dfinsupp
code: /-- A characterisation of the span of a family of submodules.

See also `Submodule.mem_iSup_iff_exists_finsupp`. -/
theorem mem_iSup_iff_exists_dfinsupp (p : ι → Submodule R N) (x : N) :
    x ∈ iSup p ↔
      ∃ f : Π₀ i, p i, DFinsupp.lsum ℕ (M := fun i ↦ ↥(p i)) (fun i => (p i).subtype) f = x 
goal: x ∈ iSup p ↔ ∃ f, ((DFinsupp.lsum ℕ) fun i => (p i).subtype) f = x

full_name: Submodule.mem_iSup_iff_exists_dfinsupp'
code: /-- A variant of `Submodule.mem_iSup_iff_exists_dfinsupp` with the RHS fully unfolded.

See also `Submodule.mem_iSup_iff_exists_finsupp`. -/
theorem mem_iSup_iff_exists_dfinsupp' (p : ι → Submodule R N) [∀ (i) (x : p i), Decidable (x ≠ 0)]
    (x : N) : x ∈ iSup p ↔ ∃ f : Π₀ i, p i, (f.sum fun i xi => ↑xi) = x 
goal: x ∈ iSup p ↔ ∃ f, (f.sum fun i xi => ↑xi) = x

full_name: Submodule.mem_biSup_iff_exists_dfinsupp
code: theorem mem_biSup_iff_exists_dfinsupp (p : ι → Prop) [DecidablePred p] (S : ι → Submodule R N)
    (x : N) :
    (x ∈ ⨆ (i) (_ : p i), S i) ↔
      ∃ f : Π₀ i, S i,
        DFinsupp.lsum ℕ (M := fun i ↦ ↥(S i)) (fun i => (S i).subtype) (f.filter p) = x 
goal: x ∈ ⨆ i, ⨆ (_ : p i), S i ↔ ∃ f, ((DFinsupp.lsum ℕ) fun i => (S i).subtype) (DFinsupp.filter p f) = x

full_name: Submodule.mem_iSup_iff_exists_finsupp
code: lemma mem_iSup_iff_exists_finsupp (p : ι → Submodule R N) (x : N) :
    x ∈ iSup p ↔ ∃ (f : ι →₀ N), (∀ i, f i ∈ p i) ∧ (f.sum fun _i xi ↦ xi) = x 
goal: x ∈ iSup p ↔ ∃ f, (∀ (i : ι), f i ∈ p i) ∧ (f.sum fun _i xi => xi) = x

full_name: Submodule.mem_iSup_finset_iff_exists_sum
code: theorem mem_iSup_finset_iff_exists_sum {s : Finset ι} (p : ι → Submodule R N) (a : N) :
    (a ∈ ⨆ i ∈ s, p i) ↔ ∃ μ : ∀ i, p i, (∑ i ∈ s, (μ i : N)) = a 
goal: a ∈ ⨆ i ∈ s, p i ↔ ∃ μ, ∑ i ∈ s, ↑(μ i) = a

full_name: CompleteLattice.independent_iff_forall_dfinsupp
code: /-- Independence of a family of submodules can be expressed as a quantifier over `DFinsupp`s.

This is an intermediate result used to prove
`CompleteLattice.independent_of_dfinsupp_lsum_injective` and
`CompleteLattice.Independent.dfinsupp_lsum_injective`. -/
theorem independent_iff_forall_dfinsupp (p : ι → Submodule R N) :
    Independent p ↔
      ∀ (i) (x : p i) (v : Π₀ i : ι, ↥(p i)),
        lsum ℕ (M := fun i ↦ ↥(p i)) (fun i => (p i).subtype) (erase i v) = x → x = 0 
goal: CompleteLattice.Independent p ↔
  ∀ (i : ι) (x : ↥(p i)) (v : Π₀ (i : ι), ↥(p i)),
    ((DFinsupp.lsum ℕ) fun i => (p i).subtype) (DFinsupp.erase i v) = ↑x → x = 0

full_name: CompleteLattice.independent_of_dfinsupp_lsum_injective
code: theorem independent_of_dfinsupp_lsum_injective (p : ι → Submodule R N)
    (h : Function.Injective (lsum ℕ (M := fun i ↦ ↥(p i)) fun i => (p i).subtype)) :
    Independent p 
goal: CompleteLattice.Independent p

full_name: CompleteLattice.independent_of_dfinsupp_sumAddHom_injective
code: theorem independent_of_dfinsupp_sumAddHom_injective (p : ι → AddSubmonoid N)
    (h : Function.Injective (sumAddHom fun i => (p i).subtype)) : Independent p 
goal: CompleteLattice.Independent p

full_name: CompleteLattice.lsum_comp_mapRange_toSpanSingleton
code: /-- Combining `DFinsupp.lsum` with `LinearMap.toSpanSingleton` is the same as `Finsupp.total` -/
theorem lsum_comp_mapRange_toSpanSingleton [∀ m : R, Decidable (m ≠ 0)] (p : ι → Submodule R N)
    {v : ι → N} (hv : ∀ i : ι, v i ∈ p i) :
    (lsum ℕ (M := fun i ↦ ↥(p i)) fun i => (p i).subtype : _ →ₗ[R] _).comp
        ((mapRange.linearMap fun i => LinearMap.toSpanSingleton R (↥(p i)) ⟨v i, hv i⟩ :
              _ →ₗ[R] _).comp
          (finsuppLequivDFinsupp R : (ι →₀ R) ≃ₗ[R] _).toLinearMap) =
      Finsupp.total ι N R v 
goal: ((DFinsupp.lsum ℕ) fun i => (p i).subtype) ∘ₗ
    (DFinsupp.mapRange.linearMap fun i => LinearMap.toSpanSingleton R ↥(p i) ⟨v i, ⋯⟩) ∘ₗ ↑(finsuppLequivDFinsupp R) =
  Finsupp.total ι N R v

full_name: CompleteLattice.independent_of_dfinsupp_sumAddHom_injective'
code: theorem independent_of_dfinsupp_sumAddHom_injective' (p : ι → AddSubgroup N)
    (h : Function.Injective (sumAddHom fun i => (p i).subtype)) : Independent p 
goal: CompleteLattice.Independent p

full_name: CompleteLattice.Independent.dfinsupp_lsum_injective
code: /-- The canonical map out of a direct sum of a family of submodules is injective when the submodules
are `CompleteLattice.Independent`.

Note that this is not generally true for `[Semiring R]`, for instance when `A` is the
`ℕ`-submodules of the positive and negative integers.

See `Counterexamples/DirectSumIsInternal.lean` for a proof of this fact. -/
theorem Independent.dfinsupp_lsum_injective {p : ι → Submodule R N} (h : Independent p) :
    Function.Injective (lsum ℕ (M := fun i ↦ ↥(p i)) fun i => (p i).subtype) 
goal: Function.Injective ⇑((DFinsupp.lsum ℕ) fun i => (p i).subtype)

full_name: CompleteLattice.Independent.dfinsupp_sumAddHom_injective
code: /-- The canonical map out of a direct sum of a family of additive subgroups is injective when the
additive subgroups are `CompleteLattice.Independent`. -/
theorem Independent.dfinsupp_sumAddHom_injective {p : ι → AddSubgroup N} (h : Independent p) :
    Function.Injective (sumAddHom fun i => (p i).subtype) 
goal: Function.Injective ⇑(DFinsupp.sumAddHom fun i => (p i).subtype)

full_name: CompleteLattice.independent_iff_dfinsupp_lsum_injective
code: /-- A family of submodules over an additive group are independent if and only iff `DFinsupp.lsum`
applied with `Submodule.subtype` is injective.

Note that this is not generally true for `[Semiring R]`; see
`CompleteLattice.Independent.dfinsupp_lsum_injective` for details. -/
theorem independent_iff_dfinsupp_lsum_injective (p : ι → Submodule R N) :
    Independent p ↔ Function.Injective (lsum ℕ (M := fun i ↦ ↥(p i)) fun i => (p i).subtype) 
goal: CompleteLattice.Independent p ↔ Function.Injective ⇑((DFinsupp.lsum ℕ) fun i => (p i).subtype)

full_name: CompleteLattice.independent_iff_dfinsupp_sumAddHom_injective
code: /-- A family of additive subgroups over an additive group are independent if and only if
`DFinsupp.sumAddHom` applied with `AddSubgroup.subtype` is injective. -/
theorem independent_iff_dfinsupp_sumAddHom_injective (p : ι → AddSubgroup N) :
    Independent p ↔ Function.Injective (sumAddHom fun i => (p i).subtype) 
goal: CompleteLattice.Independent p ↔ Function.Injective ⇑(DFinsupp.sumAddHom fun i => (p i).subtype)

full_name: CompleteLattice.Independent.linearIndependent
code: /-- If a family of submodules is `Independent`, then a choice of nonzero vector from each submodule
forms a linearly independent family.

See also `CompleteLattice.Independent.linearIndependent'`. -/
theorem Independent.linearIndependent [NoZeroSMulDivisors R N] (p : ι → Submodule R N)
    (hp : Independent p) {v : ι → N} (hv : ∀ i, v i ∈ p i) (hv' : ∀ i, v i ≠ 0) :
    LinearIndependent R v 
goal: LinearIndependent R v

full_name: CompleteLattice.independent_iff_linearIndependent_of_ne_zero
code: theorem independent_iff_linearIndependent_of_ne_zero [NoZeroSMulDivisors R N] {v : ι → N}
    (h_ne_zero : ∀ i, v i ≠ 0) : (Independent fun i => R ∙ v i) ↔ LinearIndependent R v 
goal: (CompleteLattice.Independent fun i => Submodule.span R {v i}) ↔ LinearIndependent R v

full_name: LinearMap.coe_dfinsupp_sum
code: theorem coe_dfinsupp_sum (t : Π₀ i, γ i) (g : ∀ i, γ i → 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.dfinsupp_sum_apply
code: @[simp]
theorem dfinsupp_sum_apply (t : Π₀ i, γ i) (g : ∀ i, γ i → 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: LinearMap.map_dfinsupp_sumAddHom
code: @[simp]
theorem map_dfinsupp_sumAddHom (f : M →ₛₗ[σ₁₂] M₂) {t : Π₀ i, γ i} {g : ∀ i, γ i →+ M} :
    f (sumAddHom g t) = sumAddHom (fun i => f.toAddMonoidHom.comp (g i)) t 
goal: f ((DFinsupp.sumAddHom g) t) = (DFinsupp.sumAddHom fun i => f.toAddMonoidHom.comp (g i)) t

full_name: LinearEquiv.map_dfinsupp_sumAddHom
code: @[simp]
theorem map_dfinsupp_sumAddHom [∀ i, AddZeroClass (γ i)] (f : M ≃ₛₗ[τ₁₂] M₂) (t : Π₀ i, γ i)
    (g : ∀ i, γ i →+ M) :
    f (sumAddHom g t) = sumAddHom (fun i => f.toAddEquiv.toAddMonoidHom.comp (g i)) t 
goal: f ((DFinsupp.sumAddHom g) t) = (DFinsupp.sumAddHom fun i => f.toAddEquiv.toAddMonoidHom.comp (g i)) t