File: Mathlib/LinearAlgebra/Pi.lean

full_name: LinearMap.pi
code: /-- `pi` construction for linear functions. From a family of linear functions it produces a linear
function into a family of modules. -/
def pi (f : (i : ι) → M₂ →ₗ[R] φ i) : M₂ →ₗ[R] (i : ι) → φ i 
goal: M₂ →ₗ[R] (i : ι) → φ i

full_name: LinearMap.pi_apply
code: @[simp]
theorem pi_apply (f : (i : ι) → M₂ →ₗ[R] φ i) (c : M₂) (i : ι) : pi f c i = f i c 
goal: (LinearMap.pi f) c i = (f i) c

full_name: LinearMap.ker_pi
code: theorem ker_pi (f : (i : ι) → M₂ →ₗ[R] φ i) : ker (pi f) = ⨅ i : ι, ker (f i) 
goal: LinearMap.ker (LinearMap.pi f) = ⨅ i, LinearMap.ker (f i)

full_name: LinearMap.pi_eq_zero
code: theorem pi_eq_zero (f : (i : ι) → M₂ →ₗ[R] φ i) : pi f = 0 ↔ ∀ i, f i = 0 
goal: LinearMap.pi f = 0 ↔ ∀ (i : ι), f i = 0

full_name: LinearMap.pi_zero
code: theorem pi_zero : pi (fun i => 0 : (i : ι) → M₂ →ₗ[R] φ i) = 0 
goal: (LinearMap.pi fun i => 0) = 0

full_name: LinearMap.pi_comp
code: theorem pi_comp (f : (i : ι) → M₂ →ₗ[R] φ i) (g : M₃ →ₗ[R] M₂) :
    (pi f).comp g = pi fun i => (f i).comp g 
goal: LinearMap.pi f ∘ₗ g = LinearMap.pi fun i => f i ∘ₗ g

full_name: LinearMap.proj
code: /-- The projections from a family of modules are linear maps.

Note:  known here as `LinearMap.proj`, this construction is in other categories called `eval`, for
example `Pi.evalMonoidHom`, `Pi.evalRingHom`. -/
def proj (i : ι) : ((i : ι) → φ i) →ₗ[R] φ i 
goal: ((i : ι) → φ i) →ₗ[R] φ i

full_name: LinearMap.coe_proj
code: @[simp]
theorem coe_proj (i : ι) : ⇑(proj i : ((i : ι) → φ i) →ₗ[R] φ i) = Function.eval i 
goal: ⇑(LinearMap.proj i) = Function.eval i

full_name: LinearMap.proj_apply
code: theorem proj_apply (i : ι) (b : (i : ι) → φ i) : (proj i : ((i : ι) → φ i) →ₗ[R] φ i) b = b i 
goal: (LinearMap.proj i) b = b i

full_name: LinearMap.proj_pi
code: theorem proj_pi (f : (i : ι) → M₂ →ₗ[R] φ i) (i : ι) : (proj i).comp (pi f) = f i 
goal: LinearMap.proj i ∘ₗ LinearMap.pi f = f i

full_name: LinearMap.iInf_ker_proj
code: theorem iInf_ker_proj : (⨅ i, ker (proj i : ((i : ι) → φ i) →ₗ[R] φ i) :
    Submodule R ((i : ι) → φ i)) = ⊥ 
goal: ⨅ i, LinearMap.ker (LinearMap.proj i) = ⊥

full_name: LinearMap.CompatibleSMul.pi
code: instance CompatibleSMul.pi (R S M N ι : Type*) [Semiring S]
    [AddCommMonoid M] [AddCommMonoid N] [SMul R M] [SMul R N] [Module S M] [Module S N]
    [LinearMap.CompatibleSMul M N R S] : LinearMap.CompatibleSMul M (ι → N) R S 
goal: LinearMap.CompatibleSMul M (ι → N) R S

full_name: LinearMap.compLeft_apply
code: /-- Linear map between the function spaces `I → M₂` and `I → M₃`, induced by a linear map `f`
between `M₂` and `M₃`. -/
@[simps]
protected def compLeft (f : M₂ →ₗ[R] M₃) (I : Type*) : (I → M₂) →ₗ[R] I → M₃ 
goal: ∀ (a : I), (f.compLeft I) h a = (⇑f ∘ h) a

full_name: LinearMap.compLeft
code: /-- Linear map between the function spaces `I → M₂` and `I → M₃`, induced by a linear map `f`
between `M₂` and `M₃`. -/
@[simps]
protected def compLeft (f : M₂ →ₗ[R] M₃) (I : Type*) : (I → M₂) →ₗ[R] I → M₃ 
goal: (I → M₂) →ₗ[R] I → M₃

full_name: LinearMap.apply_single
code: theorem apply_single [AddCommMonoid M] [Module R M] [DecidableEq ι] (f : (i : ι) → φ i →ₗ[R] M)
    (i j : ι) (x : φ i) : f j (Pi.single i x j) = (Pi.single i (f i x) : ι → M) j 
goal: (f j) (Pi.single i x j) = Pi.single i ((f i) x) j

full_name: LinearMap.single
code: /-- The `LinearMap` version of `AddMonoidHom.single` and `Pi.single`. -/
def single [DecidableEq ι] (i : ι) : φ i →ₗ[R] (i : ι) → φ i 
goal: φ i →ₗ[R] (i : ι) → φ i

full_name: LinearMap.coe_single
code: @[simp]
theorem coe_single [DecidableEq ι] (i : ι) : ⇑(single i : φ i →ₗ[R] (i : ι) → φ i) = Pi.single i 
goal: ⇑(LinearMap.single i) = Pi.single i

full_name: LinearMap.lsum_symm_apply
code: /-- The linear equivalence between linear functions on a finite product of modules and
families of functions on these modules. See note [bundled maps over different rings]. -/
@[simps symm_apply]
def lsum (S) [AddCommMonoid M] [Module R M] [Fintype ι] [DecidableEq ι] [Semiring S] [Module S M]
    [SMulCommClass R S M] : ((i : ι) → φ i →ₗ[R] M) ≃ₗ[S] ((i : ι) → φ i) →ₗ[R] M 
goal: (LinearMap.lsum R φ S).symm f i = f ∘ₗ LinearMap.single i

full_name: LinearMap.lsum
code: /-- The linear equivalence between linear functions on a finite product of modules and
families of functions on these modules. See note [bundled maps over different rings]. -/
@[simps symm_apply]
def lsum (S) [AddCommMonoid M] [Module R M] [Fintype ι] [DecidableEq ι] [Semiring S] [Module S M]
    [SMulCommClass R S M] : ((i : ι) → φ i →ₗ[R] M) ≃ₗ[S] ((i : ι) → φ i) →ₗ[R] M 
goal: ((i : ι) → φ i →ₗ[R] M) ≃ₗ[S] ((i : ι) → φ i) →ₗ[R] M

full_name: LinearMap.lsum_apply
code: @[simp]
theorem lsum_apply (S) [AddCommMonoid M] [Module R M] [Fintype ι] [DecidableEq ι] [Semiring S]
    [Module S M] [SMulCommClass R S M] (f : (i : ι) → φ i →ₗ[R] M) :
    lsum R φ S f = ∑ i : ι, (f i).comp (proj i) 
goal: (LinearMap.lsum R φ S) f = ∑ i : ι, f i ∘ₗ LinearMap.proj i

full_name: LinearMap.lsum_single
code: @[simp high]
theorem lsum_single {ι R : Type*} [Fintype ι] [DecidableEq ι] [CommRing R] {M : ι → Type*}
    [(i : ι) → AddCommGroup (M i)] [(i : ι) → Module R (M i)] :
    LinearMap.lsum R M R LinearMap.single = LinearMap.id 
goal: (LinearMap.lsum R M R) LinearMap.single = LinearMap.id

full_name: LinearMap.pi_ext
code: theorem pi_ext (h : ∀ i x, f (Pi.single i x) = g (Pi.single i x)) : f = g 
goal: f = g

full_name: LinearMap.pi_ext_iff
code: theorem pi_ext_iff : f = g ↔ ∀ i x, f (Pi.single i x) = g (Pi.single i x) 
goal: f = g ↔ ∀ (i : ι) (x : φ i), f (Pi.single i x) = g (Pi.single i x)

full_name: LinearMap.pi_ext'
code: /-- This is used as the ext lemma instead of `LinearMap.pi_ext` for reasons explained in
note [partially-applied ext lemmas]. -/
@[ext]
theorem pi_ext' (h : ∀ i, f.comp (single i) = g.comp (single i)) : f = g 
goal: f = g

full_name: LinearMap.pi_ext'_iff
code: theorem pi_ext'_iff : f = g ↔ ∀ i, f.comp (single i) = g.comp (single i) 
goal: f = g ↔ ∀ (i : ι), f ∘ₗ LinearMap.single i = g ∘ₗ LinearMap.single i

full_name: LinearMap.iInfKerProjEquiv
code: /-- If `I` and `J` are disjoint index sets, the product of the kernels of the `J`th projections of
`φ` is linearly equivalent to the product over `I`. -/
def iInfKerProjEquiv {I J : Set ι} [DecidablePred fun i => i ∈ I] (hd : Disjoint I J)
    (hu : Set.univ ⊆ I ∪ J) :
    (⨅ i ∈ J, ker (proj i : ((i : ι) → φ i) →ₗ[R] φ i) :
    Submodule R ((i : ι) → φ i)) ≃ₗ[R] (i : I) → φ i 
goal: ↥(⨅ i ∈ J, LinearMap.ker (LinearMap.proj i)) ≃ₗ[R] (i : ↑I) → φ ↑i

full_name: LinearMap.diag
code: /-- `diag i j` is the identity map if `i = j`. Otherwise it is the constant 0 map. -/
def diag (i j : ι) : φ i →ₗ[R] φ j 
goal: φ i →ₗ[R] φ j

full_name: LinearMap.update_apply
code: theorem update_apply (f : (i : ι) → M₂ →ₗ[R] φ i) (c : M₂) (i j : ι) (b : M₂ →ₗ[R] φ i) :
    (update f i b j) c = update (fun i => f i c) i (b c) j 
goal: (Function.update f i b j) c = Function.update (fun i => (f i) c) i (b c) j

full_name: LinearMap.pi_apply_eq_sum_univ
code: /-- A linear map `f` applied to `x : ι → R` can be computed using the image under `f` of elements
of the canonical basis. -/
theorem pi_apply_eq_sum_univ [Fintype ι] [DecidableEq ι] (f : (ι → R) →ₗ[R] M₂) (x : ι → R) :
    f x = ∑ i, x i • f fun j => if i = j then 1 else 0 
goal: f x = ∑ i : ι, x i • f fun j => if i = j then 1 else 0

full_name: Submodule.pi
code: /-- A version of `Set.pi` for submodules. Given an index set `I` and a family of submodules
`p : (i : ι) → Submodule R (φ i)`, `pi I s` is the submodule of dependent functions
`f : (i : ι) → φ i` such that `f i` belongs to `p a` whenever `i ∈ I`. -/
def pi (I : Set ι) (p : (i : ι) → Submodule R (φ i)) : Submodule R ((i : ι) → φ i) 
goal: Submodule R ((i : ι) → φ i)

full_name: Submodule.mem_pi
code: @[simp]
theorem mem_pi : x ∈ pi I p ↔ ∀ i ∈ I, x i ∈ p i 
goal: x ∈ Submodule.pi I p ↔ ∀ i ∈ I, x i ∈ p i

full_name: Submodule.coe_pi
code: @[simp, norm_cast]
theorem coe_pi : (pi I p : Set ((i : ι) → φ i)) = Set.pi I fun i => p i 
goal: ↑(Submodule.pi I p) = I.pi fun i => ↑(p i)

full_name: Submodule.pi_empty
code: @[simp]
theorem pi_empty (p : (i : ι) → Submodule R (φ i)) : pi ∅ p = ⊤ 
goal: Submodule.pi ∅ p = ⊤

full_name: Submodule.pi_top
code: @[simp]
theorem pi_top (s : Set ι) : (pi s fun i : ι => (⊤ : Submodule R (φ i))) = ⊤ 
goal: (Submodule.pi s fun i => ⊤) = ⊤

full_name: Submodule.pi_mono
code: theorem pi_mono {s : Set ι} (h : ∀ i ∈ s, p i ≤ q i) : pi s p ≤ pi s q 
goal: Submodule.pi s p ≤ Submodule.pi s q

full_name: Submodule.biInf_comap_proj
code: theorem biInf_comap_proj :
    ⨅ i ∈ I, comap (proj i : ((i : ι) → φ i) →ₗ[R] φ i) (p i) = pi I p 
goal: ⨅ i ∈ I, Submodule.comap (LinearMap.proj i) (p i) = Submodule.pi I p

full_name: Submodule.iInf_comap_proj
code: theorem iInf_comap_proj :
    ⨅ i, comap (proj i : ((i : ι) → φ i) →ₗ[R] φ i) (p i) = pi Set.univ p 
goal: ⨅ i, Submodule.comap (LinearMap.proj i) (p i) = Submodule.pi Set.univ p

full_name: Submodule.iSup_map_single
code: theorem iSup_map_single [DecidableEq ι] [Finite ι] :
    ⨆ i, map (LinearMap.single i : φ i →ₗ[R] (i : ι) → φ i) (p i) = pi Set.univ p 
goal: ⨆ i, Submodule.map (LinearMap.single i) (p i) = Submodule.pi Set.univ p

full_name: Submodule.le_comap_single_pi
code: theorem le_comap_single_pi [DecidableEq ι] (p : (i : ι) → Submodule R (φ i)) {i} :
    p i ≤ Submodule.comap (LinearMap.single i : φ i →ₗ[R] _) (Submodule.pi Set.univ p) 
goal: p i ≤ Submodule.comap (LinearMap.single i) (Submodule.pi Set.univ p)

full_name: LinearEquiv.piCongrRight
code: /-- Combine a family of linear equivalences into a linear equivalence of `pi`-types.

This is `Equiv.piCongrRight` as a `LinearEquiv` -/
def piCongrRight (e : (i : ι) → φ i ≃ₗ[R] ψ i) : ((i : ι) → φ i) ≃ₗ[R] (i : ι) → ψ i 
goal: ((i : ι) → φ i) ≃ₗ[R] (i : ι) → ψ i

full_name: LinearEquiv.piCongrRight_apply
code: @[simp]
theorem piCongrRight_apply (e : (i : ι) → φ i ≃ₗ[R] ψ i) (f i) :
    piCongrRight e f i = e i (f i) 
goal: (LinearEquiv.piCongrRight e) f i = (e i) (f i)

full_name: LinearEquiv.piCongrRight_refl
code: @[simp]
theorem piCongrRight_refl : (piCongrRight fun j => refl R (φ j)) = refl _ _ 
goal: (LinearEquiv.piCongrRight fun j => LinearEquiv.refl R (φ j)) = LinearEquiv.refl R ((i : ι) → φ i)

full_name: LinearEquiv.piCongrRight_symm
code: @[simp]
theorem piCongrRight_symm (e : (i : ι) → φ i ≃ₗ[R] ψ i) :
    (piCongrRight e).symm = piCongrRight fun i => (e i).symm 
goal: (LinearEquiv.piCongrRight e).symm = LinearEquiv.piCongrRight fun i => (e i).symm

full_name: LinearEquiv.piCongrRight_trans
code: @[simp]
theorem piCongrRight_trans (e : (i : ι) → φ i ≃ₗ[R] ψ i) (f : (i : ι) → ψ i ≃ₗ[R] χ i) :
    (piCongrRight e).trans (piCongrRight f) = piCongrRight fun i => (e i).trans (f i) 
goal: LinearEquiv.piCongrRight e ≪≫ₗ LinearEquiv.piCongrRight f = LinearEquiv.piCongrRight fun i => e i ≪≫ₗ f i

full_name: LinearEquiv.piCongrLeft'_symm_apply
code: /-- Transport dependent functions through an equivalence of the base space.

This is `Equiv.piCongrLeft'` as a `LinearEquiv`. -/
@[simps (config := { simpRhs := true })]
def piCongrLeft' (e : ι ≃ ι') : ((i' : ι) → φ i') ≃ₗ[R] (i : ι') → φ <| e.symm i 
goal: ∀ (a : (b : ι') → φ (e.symm b)) (a_1 : ι), (LinearEquiv.piCongrLeft' R φ e).symm a a_1 = ⋯ ▸ a (e a_1)

full_name: LinearEquiv.piCongrLeft'_apply
code: /-- Transport dependent functions through an equivalence of the base space.

This is `Equiv.piCongrLeft'` as a `LinearEquiv`. -/
@[simps (config := { simpRhs := true })]
def piCongrLeft' (e : ι ≃ ι') : ((i' : ι) → φ i') ≃ₗ[R] (i : ι') → φ <| e.symm i 
goal: ∀ (a : (a : ι) → φ a) (b : ι'), (LinearEquiv.piCongrLeft' R φ e) a b = a (e.symm b)

full_name: LinearEquiv.piCongrLeft'
code: /-- Transport dependent functions through an equivalence of the base space.

This is `Equiv.piCongrLeft'` as a `LinearEquiv`. -/
@[simps (config := { simpRhs := true })]
def piCongrLeft' (e : ι ≃ ι') : ((i' : ι) → φ i') ≃ₗ[R] (i : ι') → φ <| e.symm i 
goal: ((i' : ι) → φ i') ≃ₗ[R] (i : ι') → φ (e.symm i)

full_name: LinearEquiv.piCongrLeft
code: /-- Transporting dependent functions through an equivalence of the base,
expressed as a "simplification".

This is `Equiv.piCongrLeft` as a `LinearEquiv` -/
def piCongrLeft (e : ι' ≃ ι) : ((i' : ι') → φ (e i')) ≃ₗ[R] (i : ι) → φ i 
goal: ((i' : ι') → φ (e i')) ≃ₗ[R] (i : ι) → φ i

full_name: LinearEquiv.piCurry
code: /-- `Equiv.piCurry` as a `LinearEquiv`. -/
def piCurry {ι : Type*} {κ : ι → Type*} (α : ∀ i, κ i → Type*)
    [∀ i k, AddCommMonoid (α i k)] [∀ i k, Module R (α i k)] :
    (Π i : Sigma κ, α i.1 i.2) ≃ₗ[R] Π i j, α i j 
goal: ((i : Sigma κ) → α i.fst i.snd) ≃ₗ[R] (i : ι) → (j : κ i) → α i j

full_name: LinearEquiv.piCurry_apply
code: @[simp] theorem piCurry_apply {ι : Type*} {κ : ι → Type*} (α : ∀ i, κ i → Type*)
    [∀ i k, AddCommMonoid (α i k)] [∀ i k, Module R (α i k)]
    (f : ∀ x : Σ i, κ i, α x.1 x.2) :
    piCurry R α f = Sigma.curry f 
goal: (LinearEquiv.piCurry R α) f = Sigma.curry f

full_name: LinearEquiv.piCurry_symm_apply
code: @[simp] theorem piCurry_symm_apply {ι : Type*} {κ : ι → Type*} (α : ∀ i, κ i → Type*)
    [∀ i k, AddCommMonoid (α i k)] [∀ i k, Module R (α i k)]
    (f : ∀ a b, α a b) :
    (piCurry R α).symm f = Sigma.uncurry f 
goal: (LinearEquiv.piCurry R α).symm f = Sigma.uncurry f

full_name: LinearEquiv.piOptionEquivProd
code: /-- This is `Equiv.piOptionEquivProd` as a `LinearEquiv` -/
def piOptionEquivProd {ι : Type*} {M : Option ι → Type*} [(i : Option ι) → AddCommGroup (M i)]
    [(i : Option ι) → Module R (M i)] :
    ((i : Option ι) → M i) ≃ₗ[R] M none × ((i : ι) → M (some i)) 
goal: ((i : Option ι) → M i) ≃ₗ[R] M none × ((i : ι) → M (some i))

full_name: LinearEquiv.piRing
code: /-- Linear equivalence between linear functions `Rⁿ → M` and `Mⁿ`. The spaces `Rⁿ` and `Mⁿ`
are represented as `ι → R` and `ι → M`, respectively, where `ι` is a finite type.

This as an `S`-linear equivalence, under the assumption that `S` acts on `M` commuting with `R`.
When `R` is commutative, we can take this to be the usual action with `S = R`.
Otherwise, `S = ℕ` shows that the equivalence is additive.
See note [bundled maps over different rings]. -/
def piRing : ((ι → R) →ₗ[R] M) ≃ₗ[S] ι → M 
goal: ((ι → R) →ₗ[R] M) ≃ₗ[S] ι → M

full_name: LinearEquiv.piRing_apply
code: @[simp]
theorem piRing_apply (f : (ι → R) →ₗ[R] M) (i : ι) : piRing R M ι S f i = f (Pi.single i 1) 
goal: (LinearEquiv.piRing R M ι S) f i = f (Pi.single i 1)

full_name: LinearEquiv.piRing_symm_apply
code: @[simp]
theorem piRing_symm_apply (f : ι → M) (g : ι → R) : (piRing R M ι S).symm f g = ∑ i, g i • f i 
goal: ((LinearEquiv.piRing R M ι S).symm f) g = ∑ i : ι, g i • f i

full_name: LinearEquiv.sumArrowLequivProdArrow
code: /-- `Equiv.sumArrowEquivProdArrow` as a linear equivalence.
-/
def sumArrowLequivProdArrow (α β R M : Type*) [Semiring R] [AddCommMonoid M] [Module R M] :
    (α ⊕ β → M) ≃ₗ[R] (α → M) × (β → M) 
goal: (α ⊕ β → M) ≃ₗ[R] (α → M) × (β → M)

full_name: LinearEquiv.sumArrowLequivProdArrow_apply_fst
code: @[simp]
theorem sumArrowLequivProdArrow_apply_fst {α β} (f : α ⊕ β → M) (a : α) :
    (sumArrowLequivProdArrow α β R M f).1 a = f (Sum.inl a) 
goal: ((LinearEquiv.sumArrowLequivProdArrow α β R M) f).1 a = f (Sum.inl a)

full_name: LinearEquiv.sumArrowLequivProdArrow_apply_snd
code: @[simp]
theorem sumArrowLequivProdArrow_apply_snd {α β} (f : α ⊕ β → M) (b : β) :
    (sumArrowLequivProdArrow α β R M f).2 b = f (Sum.inr b) 
goal: ((LinearEquiv.sumArrowLequivProdArrow α β R M) f).2 b = f (Sum.inr b)

full_name: LinearEquiv.sumArrowLequivProdArrow_symm_apply_inl
code: @[simp]
theorem sumArrowLequivProdArrow_symm_apply_inl {α β} (f : α → M) (g : β → M) (a : α) :
    ((sumArrowLequivProdArrow α β R M).symm (f, g)) (Sum.inl a) = f a 
goal: (LinearEquiv.sumArrowLequivProdArrow α β R M).symm (f, g) (Sum.inl a) = f a

full_name: LinearEquiv.sumArrowLequivProdArrow_symm_apply_inr
code: @[simp]
theorem sumArrowLequivProdArrow_symm_apply_inr {α β} (f : α → M) (g : β → M) (b : β) :
    ((sumArrowLequivProdArrow α β R M).symm (f, g)) (Sum.inr b) = g b 
goal: (LinearEquiv.sumArrowLequivProdArrow α β R M).symm (f, g) (Sum.inr b) = g b

full_name: LinearEquiv.funUnique_symm_apply
code: /-- If `ι` has a unique element, then `ι → M` is linearly equivalent to `M`. -/
@[simps (config := { simpRhs := true, fullyApplied := false }) symm_apply]
def funUnique (ι R M : Type*) [Unique ι] [Semiring R] [AddCommMonoid M] [Module R M] :
    (ι → M) ≃ₗ[R] M 
goal: ⇑(LinearEquiv.funUnique ι R M).symm = uniqueElim

full_name: LinearEquiv.funUnique
code: /-- If `ι` has a unique element, then `ι → M` is linearly equivalent to `M`. -/
@[simps (config := { simpRhs := true, fullyApplied := false }) symm_apply]
def funUnique (ι R M : Type*) [Unique ι] [Semiring R] [AddCommMonoid M] [Module R M] :
    (ι → M) ≃ₗ[R] M 
goal: (ι → M) ≃ₗ[R] M

full_name: LinearEquiv.funUnique_apply
code: @[simp]
theorem funUnique_apply (ι R M : Type*) [Unique ι] [Semiring R] [AddCommMonoid M] [Module R M] :
    (funUnique ι R M : (ι → M) → M) = eval default 
goal: ⇑(LinearEquiv.funUnique ι R M) = Function.eval default

full_name: LinearEquiv.piFinTwo_symm_apply
code: /-- Linear equivalence between dependent functions `(i : Fin 2) → M i` and `M 0 × M 1`. -/
@[simps (config := { simpRhs := true, fullyApplied := false }) symm_apply]
def piFinTwo (M : Fin 2 → Type v)
    [(i : Fin 2) → AddCommMonoid (M i)] [(i : Fin 2) → Module R (M i)] :
    ((i : Fin 2) → M i) ≃ₗ[R] M 0 × M 1 
goal: ⇑(LinearEquiv.piFinTwo R M).symm = fun p => Fin.cons p.1 (Fin.cons p.2 finZeroElim)

full_name: LinearEquiv.piFinTwo
code: /-- Linear equivalence between dependent functions `(i : Fin 2) → M i` and `M 0 × M 1`. -/
@[simps (config := { simpRhs := true, fullyApplied := false }) symm_apply]
def piFinTwo (M : Fin 2 → Type v)
    [(i : Fin 2) → AddCommMonoid (M i)] [(i : Fin 2) → Module R (M i)] :
    ((i : Fin 2) → M i) ≃ₗ[R] M 0 × M 1 
goal: ((i : Fin 2) → M i) ≃ₗ[R] M 0 × M 1

full_name: LinearEquiv.piFinTwo_apply
code: @[simp]
theorem piFinTwo_apply (M : Fin 2 → Type v)
    [(i : Fin 2) → AddCommMonoid (M i)] [(i : Fin 2) → Module R (M i)] :
    (piFinTwo R M : ((i : Fin 2) → M i) → M 0 × M 1) = fun f => (f 0, f 1) 
goal: ⇑(LinearEquiv.piFinTwo R M) = fun f => (f 0, f 1)

full_name: LinearEquiv.finTwoArrow
code: /-- Linear equivalence between vectors in `M² = Fin 2 → M` and `M × M`. -/
@[simps! (config := .asFn)]
def finTwoArrow : (Fin 2 → M) ≃ₗ[R] M × M 
goal: (Fin 2 → M) ≃ₗ[R] M × M

full_name: LinearEquiv.finTwoArrow_apply
code: /-- Linear equivalence between vectors in `M² = Fin 2 → M` and `M × M`. -/
@[simps! (config := .asFn)]
def finTwoArrow : (Fin 2 → M) ≃ₗ[R] M × M 
goal: ⇑(LinearEquiv.finTwoArrow R M) = fun f => (f 0, f 1)

full_name: LinearEquiv.finTwoArrow_symm_apply
code: /-- Linear equivalence between vectors in `M² = Fin 2 → M` and `M × M`. -/
@[simps! (config := .asFn)]
def finTwoArrow : (Fin 2 → M) ≃ₗ[R] M × M 
goal: ⇑(LinearEquiv.finTwoArrow R M).symm = fun x => ![x.1, x.2]

full_name: Function.ExtendByZero.linearMap_apply
code: /-- `Function.extend s f 0` as a bundled linear map. -/
@[simps]
noncomputable def Function.ExtendByZero.linearMap : (ι → R) →ₗ[R] η → R 
goal: ∀ (a : η), (Function.ExtendByZero.linearMap R s) f a = Function.extend s f 0 a

full_name: Function.ExtendByZero.linearMap
code: /-- `Function.extend s f 0` as a bundled linear map. -/
@[simps]
noncomputable def Function.ExtendByZero.linearMap : (ι → R) →ₗ[R] η → R 
goal: (ι → R) →ₗ[R] η → R

full_name: LinearMap.vecEmpty
code: /-- The linear map defeq to `Matrix.vecEmpty` -/
def LinearMap.vecEmpty : M →ₗ[R] Fin 0 → M₃ 
goal: M →ₗ[R] Fin 0 → M₃

full_name: LinearMap.vecEmpty_apply
code: @[simp]
theorem LinearMap.vecEmpty_apply (m : M) : (LinearMap.vecEmpty : M →ₗ[R] Fin 0 → M₃) m = ![] 
goal: LinearMap.vecEmpty m = ![]

full_name: LinearMap.vecCons
code: /-- A linear map into `Fin n.succ → M₃` can be built out of a map into `M₃` and a map into
`Fin n → M₃`. -/
def LinearMap.vecCons {n} (f : M →ₗ[R] M₂) (g : M →ₗ[R] Fin n → M₂) : M →ₗ[R] Fin n.succ → M₂ 
goal: M →ₗ[R] Fin n.succ → M₂

full_name: LinearMap.vecCons_apply
code: @[simp]
theorem LinearMap.vecCons_apply {n} (f : M →ₗ[R] M₂) (g : M →ₗ[R] Fin n → M₂) (m : M) :
    f.vecCons g m = Matrix.vecCons (f m) (g m) 
goal: (f.vecCons g) m = Matrix.vecCons (f m) (g m)

full_name: LinearMap.vecEmpty₂_apply
code: /-- The empty bilinear map defeq to `Matrix.vecEmpty` -/
@[simps]
def LinearMap.vecEmpty₂ : M →ₗ[R] M₂ →ₗ[R] Fin 0 → M₃ 
goal: ∀ (x : M), LinearMap.vecEmpty₂ x = LinearMap.vecEmpty

full_name: LinearMap.vecEmpty₂
code: /-- The empty bilinear map defeq to `Matrix.vecEmpty` -/
@[simps]
def LinearMap.vecEmpty₂ : M →ₗ[R] M₂ →ₗ[R] Fin 0 → M₃ 
goal: M →ₗ[R] M₂ →ₗ[R] Fin 0 → M₃

full_name: LinearMap.vecCons₂
code: /-- A bilinear map into `Fin n.succ → M₃` can be built out of a map into `M₃` and a map into
`Fin n → M₃` -/
@[simps]
def LinearMap.vecCons₂ {n} (f : M →ₗ[R] M₂ →ₗ[R] M₃) (g : M →ₗ[R] M₂ →ₗ[R] Fin n → M₃) :
    M →ₗ[R] M₂ →ₗ[R] Fin n.succ → M₃ 
goal: M →ₗ[R] M₂ →ₗ[R] Fin n.succ → M₃

full_name: LinearMap.vecCons₂_apply
code: /-- A bilinear map into `Fin n.succ → M₃` can be built out of a map into `M₃` and a map into
`Fin n → M₃` -/
@[simps]
def LinearMap.vecCons₂ {n} (f : M →ₗ[R] M₂ →ₗ[R] M₃) (g : M →ₗ[R] M₂ →ₗ[R] Fin n → M₃) :
    M →ₗ[R] M₂ →ₗ[R] Fin n.succ → M₃ 
goal: (f.vecCons₂ g) m = (f m).vecCons (g m)