File: Mathlib/LinearAlgebra/StdBasis.lean

full_name: LinearMap.stdBasis
code: /-- The standard basis of the product of `φ`. -/
def stdBasis : ∀ i : ι, φ i →ₗ[R] ∀ i, φ i 
goal: φ i →ₗ[R] (i : ι) → φ i

full_name: LinearMap.stdBasis_apply
code: theorem stdBasis_apply (i : ι) (b : φ i) : stdBasis R φ i b = update (0 : (a : ι) → φ a) i b 
goal: (LinearMap.stdBasis R φ i) b = Function.update 0 i b

full_name: LinearMap.stdBasis_apply'
code: @[simp]
theorem stdBasis_apply' (i i' : ι) : (stdBasis R (fun _x : ι => R) i) 1 i' = ite (i = i') 1 0 
goal: (LinearMap.stdBasis R (fun _x => R) i) 1 i' = if i = i' then 1 else 0

full_name: LinearMap.coe_stdBasis
code: theorem coe_stdBasis (i : ι) : ⇑(stdBasis R φ i) = Pi.single i 
goal: ⇑(LinearMap.stdBasis R φ i) = Pi.single i

full_name: LinearMap.stdBasis_same
code: @[simp]
theorem stdBasis_same (i : ι) (b : φ i) : stdBasis R φ i b i = b 
goal: (LinearMap.stdBasis R φ i) b i = b

full_name: LinearMap.stdBasis_ne
code: theorem stdBasis_ne (i j : ι) (h : j ≠ i) (b : φ i) : stdBasis R φ i b j = 0 
goal: (LinearMap.stdBasis R φ i) b j = 0

full_name: LinearMap.stdBasis_eq_pi_diag
code: theorem stdBasis_eq_pi_diag (i : ι) : stdBasis R φ i = pi (diag i) 
goal: LinearMap.stdBasis R φ i = LinearMap.pi (LinearMap.diag i)

full_name: LinearMap.ker_stdBasis
code: theorem ker_stdBasis (i : ι) : ker (stdBasis R φ i) = ⊥ 
goal: LinearMap.ker (LinearMap.stdBasis R φ i) = ⊥

full_name: LinearMap.proj_comp_stdBasis
code: theorem proj_comp_stdBasis (i j : ι) : (proj i).comp (stdBasis R φ j) = diag j i 
goal: LinearMap.proj i ∘ₗ LinearMap.stdBasis R φ j = LinearMap.diag j i

full_name: LinearMap.proj_stdBasis_same
code: theorem proj_stdBasis_same (i : ι) : (proj i).comp (stdBasis R φ i) = id 
goal: LinearMap.proj i ∘ₗ LinearMap.stdBasis R φ i = LinearMap.id

full_name: LinearMap.proj_stdBasis_ne
code: theorem proj_stdBasis_ne (i j : ι) (h : i ≠ j) : (proj i).comp (stdBasis R φ j) = 0 
goal: LinearMap.proj i ∘ₗ LinearMap.stdBasis R φ j = 0

full_name: LinearMap.iSup_range_stdBasis_le_iInf_ker_proj
code: theorem iSup_range_stdBasis_le_iInf_ker_proj (I J : Set ι) (h : Disjoint I J) :
    ⨆ i ∈ I, range (stdBasis R φ i) ≤ ⨅ i ∈ J, ker (proj i : (∀ i, φ i) →ₗ[R] φ i) 
goal: ⨆ i ∈ I, LinearMap.range (LinearMap.stdBasis R φ i) ≤ ⨅ i ∈ J, LinearMap.ker (LinearMap.proj i)

full_name: LinearMap.iInf_ker_proj_le_iSup_range_stdBasis
code: theorem iInf_ker_proj_le_iSup_range_stdBasis {I : Finset ι} {J : Set ι} (hu : Set.univ ⊆ ↑I ∪ J) :
    ⨅ i ∈ J, ker (proj i : (∀ i, φ i) →ₗ[R] φ i) ≤ ⨆ i ∈ I, range (stdBasis R φ i) 
goal: ⨅ i ∈ J, LinearMap.ker (LinearMap.proj i) ≤ ⨆ i ∈ I, LinearMap.range (LinearMap.stdBasis R φ i)

full_name: LinearMap.iSup_range_stdBasis_eq_iInf_ker_proj
code: theorem iSup_range_stdBasis_eq_iInf_ker_proj {I J : Set ι} (hd : Disjoint I J)
    (hu : Set.univ ⊆ I ∪ J) (hI : Set.Finite I) :
    ⨆ i ∈ I, range (stdBasis R φ i) = ⨅ i ∈ J, ker (proj i : (∀ i, φ i) →ₗ[R] φ i) 
goal: ⨆ i ∈ I, LinearMap.range (LinearMap.stdBasis R φ i) = ⨅ i ∈ J, LinearMap.ker (LinearMap.proj i)

full_name: LinearMap.iSup_range_stdBasis
code: theorem iSup_range_stdBasis [Finite ι] : ⨆ i, range (stdBasis R φ i) = ⊤ 
goal: ⨆ i, LinearMap.range (LinearMap.stdBasis R φ i) = ⊤

full_name: LinearMap.disjoint_stdBasis_stdBasis
code: theorem disjoint_stdBasis_stdBasis (I J : Set ι) (h : Disjoint I J) :
    Disjoint (⨆ i ∈ I, range (stdBasis R φ i)) (⨆ i ∈ J, range (stdBasis R φ i)) 
goal: Disjoint (⨆ i ∈ I, LinearMap.range (LinearMap.stdBasis R φ i)) (⨆ i ∈ J, LinearMap.range (LinearMap.stdBasis R φ i))

full_name: LinearMap.stdBasis_eq_single
code: theorem stdBasis_eq_single {a : R} :
    (fun i : ι => (stdBasis R (fun _ : ι => R) i) a) = fun i : ι => ↑(Finsupp.single i a) 
goal: (fun i => (LinearMap.stdBasis R (fun x => R) i) a) = fun i => ⇑(Finsupp.single i a)

full_name: Pi.linearIndependent_stdBasis
code: theorem linearIndependent_stdBasis [Ring R] [∀ i, AddCommGroup (Ms i)] [∀ i, Module R (Ms i)]
    [DecidableEq η] (v : ∀ j, ιs j → Ms j) (hs : ∀ i, LinearIndependent R (v i)) :
    LinearIndependent R fun ji : Σj, ιs j => stdBasis R Ms ji.1 (v ji.1 ji.2) 
goal: LinearIndependent R fun ji => (LinearMap.stdBasis R Ms ji.fst) (v ji.fst ji.snd)

full_name: Pi.basis
code: /-- `Pi.basis (s : ∀ j, Basis (ιs j) R (Ms j))` is the `Σ j, ιs j`-indexed basis on `Π j, Ms j`
given by `s j` on each component.

For the standard basis over `R` on the finite-dimensional space `η → R` see `Pi.basisFun`.
-/
protected noncomputable def basis (s : ∀ j, Basis (ιs j) R (Ms j)) :
    Basis (Σj, ιs j) R (∀ j, Ms j) 
goal: Basis ((j : η) × ιs j) R ((j : η) → Ms j)

full_name: Pi.basis_repr_stdBasis
code: @[simp]
theorem basis_repr_stdBasis [DecidableEq η] (s : ∀ j, Basis (ιs j) R (Ms j)) (j i) :
    (Pi.basis s).repr (stdBasis R _ j (s j i)) = Finsupp.single ⟨j, i⟩ 1 
goal: (Pi.basis s).repr ((LinearMap.stdBasis R Ms j) ((s j) i)) = Finsupp.single ⟨j, i⟩ 1

full_name: Pi.basis_apply
code: @[simp]
theorem basis_apply [DecidableEq η] (s : ∀ j, Basis (ιs j) R (Ms j)) (ji) :
    Pi.basis s ji = stdBasis R _ ji.1 (s ji.1 ji.2) 
goal: (Pi.basis s) ji = (LinearMap.stdBasis R Ms ji.fst) ((s ji.fst) ji.snd)

full_name: Pi.basis_repr
code: @[simp]
theorem basis_repr (s : ∀ j, Basis (ιs j) R (Ms j)) (x) (ji) :
    (Pi.basis s).repr x ji = (s ji.1).repr (x ji.1) ji.2 
goal: ((Pi.basis s).repr x) ji = ((s ji.fst).repr (x ji.fst)) ji.snd

full_name: Pi.basisFun
code: /-- The basis on `η → R` where the `i`th basis vector is `Function.update 0 i 1`. -/
noncomputable def basisFun : Basis η R (η → R) 
goal: Basis η R (η → R)

full_name: Pi.basisFun_apply
code: @[simp]
theorem basisFun_apply [DecidableEq η] (i) : basisFun R η i = stdBasis R (fun _ : η => R) i 1 
goal: (Pi.basisFun R η) i = (LinearMap.stdBasis R (fun x => R) i) 1

full_name: Pi.basisFun_repr
code: @[simp]
theorem basisFun_repr (x : η → R) (i : η) : (Pi.basisFun R η).repr x i = x i 
goal: ((Pi.basisFun R η).repr x) i = x i

full_name: Pi.basisFun_equivFun
code: @[simp]
theorem basisFun_equivFun : (Pi.basisFun R η).equivFun = LinearEquiv.refl _ _ 
goal: (Pi.basisFun R η).equivFun = LinearEquiv.refl R (η → R)

full_name: Module.piEquiv
code: /-- The natural linear equivalence: `Mⁱ ≃ Hom(Rⁱ, M)` for an `R`-module `M`. -/
noncomputable def piEquiv : (ι → M) ≃ₗ[R] ((ι → R) →ₗ[R] M) 
goal: (ι → M) ≃ₗ[R] (ι → R) →ₗ[R] M

full_name: Module.piEquiv_apply_apply
code: lemma piEquiv_apply_apply (ι R M : Type*) [Fintype ι] [CommSemiring R]
    [AddCommMonoid M] [Module R M] (v : ι → M) (w : ι → R) :
    piEquiv ι R M v w = ∑ i, w i • v i 
goal: ((Module.piEquiv ι R M) v) w = ∑ i : ι, w i • v i

full_name: Module.range_piEquiv
code: @[simp] lemma range_piEquiv (v : ι → M) :
    LinearMap.range (piEquiv ι R M v) = span R (range v) 
goal: LinearMap.range ((Module.piEquiv ι R M) v) = Submodule.span R (Set.range v)

full_name: Module.surjective_piEquiv_apply_iff
code: @[simp] lemma surjective_piEquiv_apply_iff (v : ι → M) :
    Surjective (piEquiv ι R M v) ↔ span R (range v) = ⊤ 
goal: Function.Surjective ⇑((Module.piEquiv ι R M) v) ↔ Submodule.span R (Set.range v) = ⊤

full_name: Matrix.stdBasis
code: /-- The standard basis of `Matrix m n R`. -/
noncomputable def stdBasis : Basis (m × n) R (Matrix m n R) 
goal: Basis (m × n) R (Matrix m n R)

full_name: Matrix.stdBasis_eq_stdBasisMatrix
code: theorem stdBasis_eq_stdBasisMatrix (i : m) (j : n) [DecidableEq m] [DecidableEq n] :
    stdBasis R m n (i, j) = stdBasisMatrix i j (1 : R) 
goal: (Matrix.stdBasis R m n) (i, j) = Matrix.stdBasisMatrix i j 1