File: Mathlib/LinearAlgebra/Prod.lean

full_name: LinearMap.fst
code: /-- The first projection of a product is a linear map. -/
def fst : M × M₂ →ₗ[R] M 
goal: M × M₂ →ₗ[R] M

full_name: LinearMap.snd
code: /-- The second projection of a product is a linear map. -/
def snd : M × M₂ →ₗ[R] M₂ 
goal: M × M₂ →ₗ[R] M₂

full_name: LinearMap.fst_apply
code: @[simp]
theorem fst_apply (x : M × M₂) : fst R M M₂ x = x.1 
goal: (LinearMap.fst R M M₂) x = x.1

full_name: LinearMap.snd_apply
code: @[simp]
theorem snd_apply (x : M × M₂) : snd R M M₂ x = x.2 
goal: (LinearMap.snd R M M₂) x = x.2

full_name: LinearMap.fst_surjective
code: theorem fst_surjective : Function.Surjective (fst R M M₂) 
goal: Function.Surjective ⇑(LinearMap.fst R M M₂)

full_name: LinearMap.snd_surjective
code: theorem snd_surjective : Function.Surjective (snd R M M₂) 
goal: Function.Surjective ⇑(LinearMap.snd R M M₂)

full_name: LinearMap.prod_apply
code: /-- The prod of two linear maps is a linear map. -/
@[simps]
def prod (f : M →ₗ[R] M₂) (g : M →ₗ[R] M₃) : M →ₗ[R] M₂ × M₃ 
goal: (f.prod g) i = Pi.prod (⇑f) (⇑g) i

full_name: LinearMap.prod
code: /-- The prod of two linear maps is a linear map. -/
@[simps]
def prod (f : M →ₗ[R] M₂) (g : M →ₗ[R] M₃) : M →ₗ[R] M₂ × M₃ 
goal: M →ₗ[R] M₂ × M₃

full_name: LinearMap.coe_prod
code: theorem coe_prod (f : M →ₗ[R] M₂) (g : M →ₗ[R] M₃) : ⇑(f.prod g) = Pi.prod f g 
goal: ⇑(f.prod g) = Pi.prod ⇑f ⇑g

full_name: LinearMap.fst_prod
code: @[simp]
theorem fst_prod (f : M →ₗ[R] M₂) (g : M →ₗ[R] M₃) : (fst R M₂ M₃).comp (prod f g) = f 
goal: LinearMap.fst R M₂ M₃ ∘ₗ f.prod g = f

full_name: LinearMap.snd_prod
code: @[simp]
theorem snd_prod (f : M →ₗ[R] M₂) (g : M →ₗ[R] M₃) : (snd R M₂ M₃).comp (prod f g) = g 
goal: LinearMap.snd R M₂ M₃ ∘ₗ f.prod g = g

full_name: LinearMap.pair_fst_snd
code: @[simp]
theorem pair_fst_snd : prod (fst R M M₂) (snd R M M₂) = LinearMap.id 
goal: (LinearMap.fst R M M₂).prod (LinearMap.snd R M M₂) = LinearMap.id

full_name: LinearMap.prod_comp
code: theorem prod_comp (f : M₂ →ₗ[R] M₃) (g : M₂ →ₗ[R] M₄)
    (h : M →ₗ[R] M₂) : (f.prod g).comp h = (f.comp h).prod (g.comp h) 
goal: f.prod g ∘ₗ h = (f ∘ₗ h).prod (g ∘ₗ h)

full_name: LinearMap.prodEquiv_apply
code: /-- Taking the product of two maps with the same domain is equivalent to taking the product of
their codomains.

See note [bundled maps over different rings] for why separate `R` and `S` semirings are used. -/
@[simps]
def prodEquiv [Module S M₂] [Module S M₃] [SMulCommClass R S M₂] [SMulCommClass R S M₃] :
    ((M →ₗ[R] M₂) × (M →ₗ[R] M₃)) ≃ₗ[S] M →ₗ[R] M₂ × M₃ 
goal: (LinearMap.prodEquiv S) f = f.1.prod f.2

full_name: LinearMap.prodEquiv_symm_apply
code: /-- Taking the product of two maps with the same domain is equivalent to taking the product of
their codomains.

See note [bundled maps over different rings] for why separate `R` and `S` semirings are used. -/
@[simps]
def prodEquiv [Module S M₂] [Module S M₃] [SMulCommClass R S M₂] [SMulCommClass R S M₃] :
    ((M →ₗ[R] M₂) × (M →ₗ[R] M₃)) ≃ₗ[S] M →ₗ[R] M₂ × M₃ 
goal: (LinearMap.prodEquiv S).symm f = (LinearMap.fst R M₂ M₃ ∘ₗ f, LinearMap.snd R M₂ M₃ ∘ₗ f)

full_name: LinearMap.prodEquiv
code: /-- Taking the product of two maps with the same domain is equivalent to taking the product of
their codomains.

See note [bundled maps over different rings] for why separate `R` and `S` semirings are used. -/
@[simps]
def prodEquiv [Module S M₂] [Module S M₃] [SMulCommClass R S M₂] [SMulCommClass R S M₃] :
    ((M →ₗ[R] M₂) × (M →ₗ[R] M₃)) ≃ₗ[S] M →ₗ[R] M₂ × M₃ 
goal: ((M →ₗ[R] M₂) × (M →ₗ[R] M₃)) ≃ₗ[S] M →ₗ[R] M₂ × M₃

full_name: LinearMap.inl
code: /-- The left injection into a product is a linear map. -/
def inl : M →ₗ[R] M × M₂ 
goal: M →ₗ[R] M × M₂

full_name: LinearMap.inr
code: /-- The right injection into a product is a linear map. -/
def inr : M₂ →ₗ[R] M × M₂ 
goal: M₂ →ₗ[R] M × M₂

full_name: LinearMap.range_inl
code: theorem range_inl : range (inl R M M₂) = ker (snd R M M₂) 
goal: LinearMap.range (LinearMap.inl R M M₂) = LinearMap.ker (LinearMap.snd R M M₂)

full_name: LinearMap.ker_snd
code: theorem ker_snd : ker (snd R M M₂) = range (inl R M M₂) 
goal: LinearMap.ker (LinearMap.snd R M M₂) = LinearMap.range (LinearMap.inl R M M₂)

full_name: LinearMap.range_inr
code: theorem range_inr : range (inr R M M₂) = ker (fst R M M₂) 
goal: LinearMap.range (LinearMap.inr R M M₂) = LinearMap.ker (LinearMap.fst R M M₂)

full_name: LinearMap.ker_fst
code: theorem ker_fst : ker (fst R M M₂) = range (inr R M M₂) 
goal: LinearMap.ker (LinearMap.fst R M M₂) = LinearMap.range (LinearMap.inr R M M₂)

full_name: LinearMap.fst_comp_inl
code: @[simp] theorem fst_comp_inl : fst R M M₂ ∘ₗ inl R M M₂ = id 
goal: LinearMap.fst R M M₂ ∘ₗ LinearMap.inl R M M₂ = LinearMap.id

full_name: LinearMap.snd_comp_inl
code: @[simp] theorem snd_comp_inl : snd R M M₂ ∘ₗ inl R M M₂ = 0 
goal: LinearMap.snd R M M₂ ∘ₗ LinearMap.inl R M M₂ = 0

full_name: LinearMap.fst_comp_inr
code: @[simp] theorem fst_comp_inr : fst R M M₂ ∘ₗ inr R M M₂ = 0 
goal: LinearMap.fst R M M₂ ∘ₗ LinearMap.inr R M M₂ = 0

full_name: LinearMap.snd_comp_inr
code: @[simp] theorem snd_comp_inr : snd R M M₂ ∘ₗ inr R M M₂ = id 
goal: LinearMap.snd R M M₂ ∘ₗ LinearMap.inr R M M₂ = LinearMap.id

full_name: LinearMap.coe_inl
code: @[simp]
theorem coe_inl : (inl R M M₂ : M → M × M₂) = fun x => (x, 0) 
goal: ⇑(LinearMap.inl R M M₂) = fun x => (x, 0)

full_name: LinearMap.inl_apply
code: theorem inl_apply (x : M) : inl R M M₂ x = (x, 0) 
goal: (LinearMap.inl R M M₂) x = (x, 0)

full_name: LinearMap.coe_inr
code: @[simp]
theorem coe_inr : (inr R M M₂ : M₂ → M × M₂) = Prod.mk 0 
goal: ⇑(LinearMap.inr R M M₂) = Prod.mk 0

full_name: LinearMap.inr_apply
code: theorem inr_apply (x : M₂) : inr R M M₂ x = (0, x) 
goal: (LinearMap.inr R M M₂) x = (0, x)

full_name: LinearMap.inl_eq_prod
code: theorem inl_eq_prod : inl R M M₂ = prod LinearMap.id 0 
goal: LinearMap.inl R M M₂ = LinearMap.id.prod 0

full_name: LinearMap.inr_eq_prod
code: theorem inr_eq_prod : inr R M M₂ = prod 0 LinearMap.id 
goal: LinearMap.inr R M M₂ = LinearMap.prod 0 LinearMap.id

full_name: LinearMap.inl_injective
code: theorem inl_injective : Function.Injective (inl R M M₂) 
goal: Function.Injective ⇑(LinearMap.inl R M M₂)

full_name: LinearMap.inr_injective
code: theorem inr_injective : Function.Injective (inr R M M₂) 
goal: Function.Injective ⇑(LinearMap.inr R M M₂)

full_name: LinearMap.coprod
code: /-- The coprod function `x : M × M₂ ↦ f x.1 + g x.2` is a linear map. -/
def coprod (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₃) : M × M₂ →ₗ[R] M₃ 
goal: M × M₂ →ₗ[R] M₃

full_name: LinearMap.coprod_apply
code: @[simp]
theorem coprod_apply (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₃) (x : M × M₂) :
    coprod f g x = f x.1 + g x.2 
goal: (f.coprod g) x = f x.1 + g x.2

full_name: LinearMap.coprod_inl
code: @[simp]
theorem coprod_inl (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₃) : (coprod f g).comp (inl R M M₂) = f 
goal: f.coprod g ∘ₗ LinearMap.inl R M M₂ = f

full_name: LinearMap.coprod_inr
code: @[simp]
theorem coprod_inr (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₃) : (coprod f g).comp (inr R M M₂) = g 
goal: f.coprod g ∘ₗ LinearMap.inr R M M₂ = g

full_name: LinearMap.coprod_inl_inr
code: @[simp]
theorem coprod_inl_inr : coprod (inl R M M₂) (inr R M M₂) = LinearMap.id 
goal: (LinearMap.inl R M M₂).coprod (LinearMap.inr R M M₂) = LinearMap.id

full_name: LinearMap.coprod_zero_left
code: theorem coprod_zero_left (g : M₂ →ₗ[R] M₃) : (0 : M →ₗ[R] M₃).coprod g = g.comp (snd R M M₂) 
goal: LinearMap.coprod 0 g = g ∘ₗ LinearMap.snd R M M₂

full_name: LinearMap.coprod_zero_right
code: theorem coprod_zero_right (f : M →ₗ[R] M₃) : f.coprod (0 : M₂ →ₗ[R] M₃) = f.comp (fst R M M₂) 
goal: f.coprod 0 = f ∘ₗ LinearMap.fst R M M₂

full_name: LinearMap.comp_coprod
code: theorem comp_coprod (f : M₃ →ₗ[R] M₄) (g₁ : M →ₗ[R] M₃) (g₂ : M₂ →ₗ[R] M₃) :
    f.comp (g₁.coprod g₂) = (f.comp g₁).coprod (f.comp g₂) 
goal: f ∘ₗ g₁.coprod g₂ = (f ∘ₗ g₁).coprod (f ∘ₗ g₂)

full_name: LinearMap.fst_eq_coprod
code: theorem fst_eq_coprod : fst R M M₂ = coprod LinearMap.id 0 
goal: LinearMap.fst R M M₂ = LinearMap.id.coprod 0

full_name: LinearMap.snd_eq_coprod
code: theorem snd_eq_coprod : snd R M M₂ = coprod 0 LinearMap.id 
goal: LinearMap.snd R M M₂ = LinearMap.coprod 0 LinearMap.id

full_name: LinearMap.coprod_comp_prod
code: @[simp]
theorem coprod_comp_prod (f : M₂ →ₗ[R] M₄) (g : M₃ →ₗ[R] M₄) (f' : M →ₗ[R] M₂) (g' : M →ₗ[R] M₃) :
    (f.coprod g).comp (f'.prod g') = f.comp f' + g.comp g' 
goal: f.coprod g ∘ₗ f'.prod g' = f ∘ₗ f' + g ∘ₗ g'

full_name: LinearMap.coprod_map_prod
code: @[simp]
theorem coprod_map_prod (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₃) (S : Submodule R M)
    (S' : Submodule R M₂) : (Submodule.prod S S').map (LinearMap.coprod f g) = S.map f ⊔ S'.map g 
goal: Submodule.map (f.coprod g) (S.prod S') = Submodule.map f S ⊔ Submodule.map g S'

full_name: LinearMap.coprodEquiv_symm_apply
code: /-- Taking the product of two maps with the same codomain is equivalent to taking the product of
their domains.

See note [bundled maps over different rings] for why separate `R` and `S` semirings are used. -/
@[simps]
def coprodEquiv [Module S M₃] [SMulCommClass R S M₃] :
    ((M →ₗ[R] M₃) × (M₂ →ₗ[R] M₃)) ≃ₗ[S] M × M₂ →ₗ[R] M₃ 
goal: (LinearMap.coprodEquiv S).symm f = (f ∘ₗ LinearMap.inl R M M₂, f ∘ₗ LinearMap.inr R M M₂)

full_name: LinearMap.coprodEquiv
code: /-- Taking the product of two maps with the same codomain is equivalent to taking the product of
their domains.

See note [bundled maps over different rings] for why separate `R` and `S` semirings are used. -/
@[simps]
def coprodEquiv [Module S M₃] [SMulCommClass R S M₃] :
    ((M →ₗ[R] M₃) × (M₂ →ₗ[R] M₃)) ≃ₗ[S] M × M₂ →ₗ[R] M₃ 
goal: ((M →ₗ[R] M₃) × (M₂ →ₗ[R] M₃)) ≃ₗ[S] M × M₂ →ₗ[R] M₃

full_name: LinearMap.coprodEquiv_apply
code: /-- Taking the product of two maps with the same codomain is equivalent to taking the product of
their domains.

See note [bundled maps over different rings] for why separate `R` and `S` semirings are used. -/
@[simps]
def coprodEquiv [Module S M₃] [SMulCommClass R S M₃] :
    ((M →ₗ[R] M₃) × (M₂ →ₗ[R] M₃)) ≃ₗ[S] M × M₂ →ₗ[R] M₃ 
goal: (LinearMap.coprodEquiv S) f = f.1.coprod f.2

full_name: LinearMap.prod_ext_iff
code: theorem prod_ext_iff {f g : M × M₂ →ₗ[R] M₃} :
    f = g ↔ f.comp (inl _ _ _) = g.comp (inl _ _ _) ∧ f.comp (inr _ _ _) = g.comp (inr _ _ _) 
goal: f = g ↔ f ∘ₗ LinearMap.inl R M M₂ = g ∘ₗ LinearMap.inl R M M₂ ∧ f ∘ₗ LinearMap.inr R M M₂ = g ∘ₗ LinearMap.inr R M M₂

full_name: LinearMap.prod_ext
code: /--
Split equality of linear maps from a product into linear maps over each component, to allow `ext`
to apply lemmas specific to `M →ₗ M₃` and `M₂ →ₗ M₃`.

See note [partially-applied ext lemmas]. -/
@[ext 1100]
theorem prod_ext {f g : M × M₂ →ₗ[R] M₃} (hl : f.comp (inl _ _ _) = g.comp (inl _ _ _))
    (hr : f.comp (inr _ _ _) = g.comp (inr _ _ _)) : f = g 
goal: f = g

full_name: LinearMap.prodMap
code: /-- `prod.map` of two linear maps. -/
def prodMap (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₄) : M × M₂ →ₗ[R] M₃ × M₄ 
goal: M × M₂ →ₗ[R] M₃ × M₄

full_name: LinearMap.coe_prodMap
code: theorem coe_prodMap (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₄) : ⇑(f.prodMap g) = Prod.map f g 
goal: ⇑(f.prodMap g) = Prod.map ⇑f ⇑g

full_name: LinearMap.prodMap_apply
code: @[simp]
theorem prodMap_apply (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₄) (x) : f.prodMap g x = (f x.1, g x.2) 
goal: (f.prodMap g) x = (f x.1, g x.2)

full_name: LinearMap.prodMap_comap_prod
code: theorem prodMap_comap_prod (f : M →ₗ[R] M₂) (g : M₃ →ₗ[R] M₄) (S : Submodule R M₂)
    (S' : Submodule R M₄) :
    (Submodule.prod S S').comap (LinearMap.prodMap f g) = (S.comap f).prod (S'.comap g) 
goal: Submodule.comap (f.prodMap g) (S.prod S') = (Submodule.comap f S).prod (Submodule.comap g S')

full_name: LinearMap.ker_prodMap
code: theorem ker_prodMap (f : M →ₗ[R] M₂) (g : M₃ →ₗ[R] M₄) :
    ker (LinearMap.prodMap f g) = Submodule.prod (ker f) (ker g) 
goal: LinearMap.ker (f.prodMap g) = (LinearMap.ker f).prod (LinearMap.ker g)

full_name: LinearMap.prodMap_id
code: @[simp]
theorem prodMap_id : (id : M →ₗ[R] M).prodMap (id : M₂ →ₗ[R] M₂) = id 
goal: LinearMap.id.prodMap LinearMap.id = LinearMap.id

full_name: LinearMap.prodMap_one
code: @[simp]
theorem prodMap_one : (1 : M →ₗ[R] M).prodMap (1 : M₂ →ₗ[R] M₂) = 1 
goal: LinearMap.prodMap 1 1 = 1

full_name: LinearMap.prodMap_comp
code: theorem prodMap_comp (f₁₂ : M →ₗ[R] M₂) (f₂₃ : M₂ →ₗ[R] M₃) (g₁₂ : M₄ →ₗ[R] M₅)
    (g₂₃ : M₅ →ₗ[R] M₆) :
    f₂₃.prodMap g₂₃ ∘ₗ f₁₂.prodMap g₁₂ = (f₂₃ ∘ₗ f₁₂).prodMap (g₂₃ ∘ₗ g₁₂) 
goal: f₂₃.prodMap g₂₃ ∘ₗ f₁₂.prodMap g₁₂ = (f₂₃ ∘ₗ f₁₂).prodMap (g₂₃ ∘ₗ g₁₂)

full_name: LinearMap.prodMap_mul
code: theorem prodMap_mul (f₁₂ : M →ₗ[R] M) (f₂₃ : M →ₗ[R] M) (g₁₂ : M₂ →ₗ[R] M₂) (g₂₃ : M₂ →ₗ[R] M₂) :
    f₂₃.prodMap g₂₃ * f₁₂.prodMap g₁₂ = (f₂₃ * f₁₂).prodMap (g₂₃ * g₁₂) 
goal: f₂₃.prodMap g₂₃ * f₁₂.prodMap g₁₂ = (f₂₃ * f₁₂).prodMap (g₂₃ * g₁₂)

full_name: LinearMap.prodMap_add
code: theorem prodMap_add (f₁ : M →ₗ[R] M₃) (f₂ : M →ₗ[R] M₃) (g₁ : M₂ →ₗ[R] M₄) (g₂ : M₂ →ₗ[R] M₄) :
    (f₁ + f₂).prodMap (g₁ + g₂) = f₁.prodMap g₁ + f₂.prodMap g₂ 
goal: (f₁ + f₂).prodMap (g₁ + g₂) = f₁.prodMap g₁ + f₂.prodMap g₂

full_name: LinearMap.prodMap_zero
code: @[simp]
theorem prodMap_zero : (0 : M →ₗ[R] M₂).prodMap (0 : M₃ →ₗ[R] M₄) = 0 
goal: LinearMap.prodMap 0 0 = 0

full_name: LinearMap.prodMap_smul
code: @[simp]
theorem prodMap_smul [Module S M₃] [Module S M₄] [SMulCommClass R S M₃] [SMulCommClass R S M₄]
    (s : S) (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₄) : prodMap (s • f) (s • g) = s • prodMap f g 
goal: (s • f).prodMap (s • g) = s • f.prodMap g

full_name: LinearMap.prodMapLinear_apply
code: /-- `LinearMap.prodMap` as a `LinearMap` -/
@[simps]
def prodMapLinear [Module S M₃] [Module S M₄] [SMulCommClass R S M₃] [SMulCommClass R S M₄] :
    (M →ₗ[R] M₃) × (M₂ →ₗ[R] M₄) →ₗ[S] M × M₂ →ₗ[R] M₃ × M₄ 
goal: (LinearMap.prodMapLinear R M M₂ M₃ M₄ S) f = f.1.prodMap f.2

full_name: LinearMap.prodMapLinear
code: /-- `LinearMap.prodMap` as a `LinearMap` -/
@[simps]
def prodMapLinear [Module S M₃] [Module S M₄] [SMulCommClass R S M₃] [SMulCommClass R S M₄] :
    (M →ₗ[R] M₃) × (M₂ →ₗ[R] M₄) →ₗ[S] M × M₂ →ₗ[R] M₃ × M₄ 
goal: (M →ₗ[R] M₃) × (M₂ →ₗ[R] M₄) →ₗ[S] M × M₂ →ₗ[R] M₃ × M₄

full_name: LinearMap.prodMapRingHom
code: /-- `LinearMap.prodMap` as a `RingHom` -/
@[simps]
def prodMapRingHom : (M →ₗ[R] M) × (M₂ →ₗ[R] M₂) →+* M × M₂ →ₗ[R] M × M₂ 
goal: (M →ₗ[R] M) × (M₂ →ₗ[R] M₂) →+* M × M₂ →ₗ[R] M × M₂

full_name: LinearMap.prodMapRingHom_apply
code: /-- `LinearMap.prodMap` as a `RingHom` -/
@[simps]
def prodMapRingHom : (M →ₗ[R] M) × (M₂ →ₗ[R] M₂) →+* M × M₂ →ₗ[R] M × M₂ 
goal: (LinearMap.prodMapRingHom R M M₂) f = f.1.prodMap f.2

full_name: LinearMap.inl_map_mul
code: theorem inl_map_mul (a₁ a₂ : A) :
    LinearMap.inl R A B (a₁ * a₂) = LinearMap.inl R A B a₁ * LinearMap.inl R A B a₂ 
goal: (LinearMap.inl R A B) (a₁ * a₂) = (LinearMap.inl R A B) a₁ * (LinearMap.inl R A B) a₂

full_name: LinearMap.inr_map_mul
code: theorem inr_map_mul (b₁ b₂ : B) :
    LinearMap.inr R A B (b₁ * b₂) = LinearMap.inr R A B b₁ * LinearMap.inr R A B b₂ 
goal: (LinearMap.inr R A B) (b₁ * b₂) = (LinearMap.inr R A B) b₁ * (LinearMap.inr R A B) b₂

full_name: LinearMap.prodMapAlgHom_apply_apply
code: /-- `LinearMap.prodMap` as an `AlgHom` -/
@[simps!]
def prodMapAlgHom : Module.End R M × Module.End R M₂ →ₐ[R] Module.End R (M × M₂) 
goal: ((LinearMap.prodMapAlgHom R M M₂) f) i = (f.1 i.1, f.2 i.2)

full_name: LinearMap.prodMapAlgHom
code: /-- `LinearMap.prodMap` as an `AlgHom` -/
@[simps!]
def prodMapAlgHom : Module.End R M × Module.End R M₂ →ₐ[R] Module.End R (M × M₂) 
goal: Module.End R M × Module.End R M₂ →ₐ[R] Module.End R (M × M₂)

full_name: LinearMap.range_coprod
code: theorem range_coprod (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₃) : range (f.coprod g) = range f ⊔ range g 
goal: LinearMap.range (f.coprod g) = LinearMap.range f ⊔ LinearMap.range g

full_name: LinearMap.isCompl_range_inl_inr
code: theorem isCompl_range_inl_inr : IsCompl (range <| inl R M M₂) (range <| inr R M M₂) 
goal: IsCompl (LinearMap.range (LinearMap.inl R M M₂)) (LinearMap.range (LinearMap.inr R M M₂))

full_name: LinearMap.sup_range_inl_inr
code: theorem sup_range_inl_inr : (range <| inl R M M₂) ⊔ (range <| inr R M M₂) = ⊤ 
goal: LinearMap.range (LinearMap.inl R M M₂) ⊔ LinearMap.range (LinearMap.inr R M M₂) = ⊤

full_name: LinearMap.disjoint_inl_inr
code: theorem disjoint_inl_inr : Disjoint (range <| inl R M M₂) (range <| inr R M M₂) 
goal: Disjoint (LinearMap.range (LinearMap.inl R M M₂)) (LinearMap.range (LinearMap.inr R M M₂))

full_name: LinearMap.map_coprod_prod
code: theorem map_coprod_prod (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₃) (p : Submodule R M)
    (q : Submodule R M₂) : map (coprod f g) (p.prod q) = map f p ⊔ map g q 
goal: Submodule.map (f.coprod g) (p.prod q) = Submodule.map f p ⊔ Submodule.map g q

full_name: LinearMap.comap_prod_prod
code: theorem comap_prod_prod (f : M →ₗ[R] M₂) (g : M →ₗ[R] M₃) (p : Submodule R M₂)
    (q : Submodule R M₃) : comap (prod f g) (p.prod q) = comap f p ⊓ comap g q 
goal: Submodule.comap (f.prod g) (p.prod q) = Submodule.comap f p ⊓ Submodule.comap g q

full_name: LinearMap.prod_eq_inf_comap
code: theorem prod_eq_inf_comap (p : Submodule R M) (q : Submodule R M₂) :
    p.prod q = p.comap (LinearMap.fst R M M₂) ⊓ q.comap (LinearMap.snd R M M₂) 
goal: p.prod q = Submodule.comap (LinearMap.fst R M M₂) p ⊓ Submodule.comap (LinearMap.snd R M M₂) q

full_name: LinearMap.prod_eq_sup_map
code: theorem prod_eq_sup_map (p : Submodule R M) (q : Submodule R M₂) :
    p.prod q = p.map (LinearMap.inl R M M₂) ⊔ q.map (LinearMap.inr R M M₂) 
goal: p.prod q = Submodule.map (LinearMap.inl R M M₂) p ⊔ Submodule.map (LinearMap.inr R M M₂) q

full_name: LinearMap.span_inl_union_inr
code: theorem span_inl_union_inr {s : Set M} {t : Set M₂} :
    span R (inl R M M₂ '' s ∪ inr R M M₂ '' t) = (span R s).prod (span R t) 
goal: Submodule.span R (⇑(LinearMap.inl R M M₂) '' s ∪ ⇑(LinearMap.inr R M M₂) '' t) =
  (Submodule.span R s).prod (Submodule.span R t)

full_name: LinearMap.ker_prod
code: @[simp]
theorem ker_prod (f : M →ₗ[R] M₂) (g : M →ₗ[R] M₃) : ker (prod f g) = ker f ⊓ ker g 
goal: LinearMap.ker (f.prod g) = LinearMap.ker f ⊓ LinearMap.ker g

full_name: LinearMap.range_prod_le
code: theorem range_prod_le (f : M →ₗ[R] M₂) (g : M →ₗ[R] M₃) :
    range (prod f g) ≤ (range f).prod (range g) 
goal: LinearMap.range (f.prod g) ≤ (LinearMap.range f).prod (LinearMap.range g)

full_name: LinearMap.ker_prod_ker_le_ker_coprod
code: theorem ker_prod_ker_le_ker_coprod {M₂ : Type*} [AddCommGroup M₂] [Module R M₂] {M₃ : Type*}
    [AddCommGroup M₃] [Module R M₃] (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₃) :
    (ker f).prod (ker g) ≤ ker (f.coprod g) 
goal: (LinearMap.ker f).prod (LinearMap.ker g) ≤ LinearMap.ker (f.coprod g)

full_name: LinearMap.ker_coprod_of_disjoint_range
code: theorem ker_coprod_of_disjoint_range {M₂ : Type*} [AddCommGroup M₂] [Module R M₂] {M₃ : Type*}
    [AddCommGroup M₃] [Module R M₃] (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₃)
    (hd : Disjoint (range f) (range g)) : ker (f.coprod g) = (ker f).prod (ker g) 
goal: LinearMap.ker (f.coprod g) = (LinearMap.ker f).prod (LinearMap.ker g)

full_name: Submodule.sup_eq_range
code: theorem sup_eq_range (p q : Submodule R M) : p ⊔ q = range (p.subtype.coprod q.subtype) 
goal: p ⊔ q = LinearMap.range (p.subtype.coprod q.subtype)

full_name: Submodule.map_inl
code: @[simp]
theorem map_inl : p.map (inl R M M₂) = prod p ⊥ 
goal: Submodule.map (LinearMap.inl R M M₂) p = p.prod ⊥

full_name: Submodule.map_inr
code: @[simp]
theorem map_inr : q.map (inr R M M₂) = prod ⊥ q 
goal: Submodule.map (LinearMap.inr R M M₂) q = ⊥.prod q

full_name: Submodule.comap_fst
code: @[simp]
theorem comap_fst : p.comap (fst R M M₂) = prod p ⊤ 
goal: Submodule.comap (LinearMap.fst R M M₂) p = p.prod ⊤

full_name: Submodule.comap_snd
code: @[simp]
theorem comap_snd : q.comap (snd R M M₂) = prod ⊤ q 
goal: Submodule.comap (LinearMap.snd R M M₂) q = ⊤.prod q

full_name: Submodule.prod_comap_inl
code: @[simp]
theorem prod_comap_inl : (prod p q).comap (inl R M M₂) = p 
goal: Submodule.comap (LinearMap.inl R M M₂) (p.prod q) = p

full_name: Submodule.prod_comap_inr
code: @[simp]
theorem prod_comap_inr : (prod p q).comap (inr R M M₂) = q 
goal: Submodule.comap (LinearMap.inr R M M₂) (p.prod q) = q

full_name: Submodule.prod_map_fst
code: @[simp]
theorem prod_map_fst : (prod p q).map (fst R M M₂) = p 
goal: Submodule.map (LinearMap.fst R M M₂) (p.prod q) = p

full_name: Submodule.prod_map_snd
code: @[simp]
theorem prod_map_snd : (prod p q).map (snd R M M₂) = q 
goal: Submodule.map (LinearMap.snd R M M₂) (p.prod q) = q

full_name: Submodule.ker_inl
code: @[simp]
theorem ker_inl : ker (inl R M M₂) = ⊥ 
goal: LinearMap.ker (LinearMap.inl R M M₂) = ⊥

full_name: Submodule.ker_inr
code: @[simp]
theorem ker_inr : ker (inr R M M₂) = ⊥ 
goal: LinearMap.ker (LinearMap.inr R M M₂) = ⊥

full_name: Submodule.range_fst
code: @[simp]
theorem range_fst : range (fst R M M₂) = ⊤ 
goal: LinearMap.range (LinearMap.fst R M M₂) = ⊤

full_name: Submodule.range_snd
code: @[simp]
theorem range_snd : range (snd R M M₂) = ⊤ 
goal: LinearMap.range (LinearMap.snd R M M₂) = ⊤

full_name: Submodule.fst
code: /-- `M` as a submodule of `M × N`. -/
def fst : Submodule R (M × M₂) 
goal: Submodule R (M × M₂)

full_name: Submodule.fstEquiv_symm_apply_coe
code: /-- `M` as a submodule of `M × N` is isomorphic to `M`. -/
@[simps]
def fstEquiv : Submodule.fst R M M₂ ≃ₗ[R] M 
goal: ↑((Submodule.fstEquiv R M M₂).symm m) = (m, 0)

full_name: Submodule.fstEquiv
code: /-- `M` as a submodule of `M × N` is isomorphic to `M`. -/
@[simps]
def fstEquiv : Submodule.fst R M M₂ ≃ₗ[R] M 
goal: ↥(Submodule.fst R M M₂) ≃ₗ[R] M

full_name: Submodule.fstEquiv_apply
code: /-- `M` as a submodule of `M × N` is isomorphic to `M`. -/
@[simps]
def fstEquiv : Submodule.fst R M M₂ ≃ₗ[R] M 
goal: (Submodule.fstEquiv R M M₂) x = (↑x).1

full_name: Submodule.fst_map_fst
code: theorem fst_map_fst : (Submodule.fst R M M₂).map (LinearMap.fst R M M₂) = ⊤ 
goal: Submodule.map (LinearMap.fst R M M₂) (Submodule.fst R M M₂) = ⊤

full_name: Submodule.fst_map_snd
code: theorem fst_map_snd : (Submodule.fst R M M₂).map (LinearMap.snd R M M₂) = ⊥ 
goal: Submodule.map (LinearMap.snd R M M₂) (Submodule.fst R M M₂) = ⊥

full_name: Submodule.snd
code: /-- `N` as a submodule of `M × N`. -/
def snd : Submodule R (M × M₂) 
goal: Submodule R (M × M₂)

full_name: Submodule.sndEquiv_symm_apply_coe
code: /-- `N` as a submodule of `M × N` is isomorphic to `N`. -/
@[simps]
def sndEquiv : Submodule.snd R M M₂ ≃ₗ[R] M₂ 
goal: ↑((Submodule.sndEquiv R M M₂).symm n) = (0, n)

full_name: Submodule.sndEquiv_apply
code: /-- `N` as a submodule of `M × N` is isomorphic to `N`. -/
@[simps]
def sndEquiv : Submodule.snd R M M₂ ≃ₗ[R] M₂ 
goal: (Submodule.sndEquiv R M M₂) x = (↑x).2

full_name: Submodule.sndEquiv
code: /-- `N` as a submodule of `M × N` is isomorphic to `N`. -/
@[simps]
def sndEquiv : Submodule.snd R M M₂ ≃ₗ[R] M₂ 
goal: ↥(Submodule.snd R M M₂) ≃ₗ[R] M₂

full_name: Submodule.snd_map_fst
code: theorem snd_map_fst : (Submodule.snd R M M₂).map (LinearMap.fst R M M₂) = ⊥ 
goal: Submodule.map (LinearMap.fst R M M₂) (Submodule.snd R M M₂) = ⊥

full_name: Submodule.snd_map_snd
code: theorem snd_map_snd : (Submodule.snd R M M₂).map (LinearMap.snd R M M₂) = ⊤ 
goal: Submodule.map (LinearMap.snd R M M₂) (Submodule.snd R M M₂) = ⊤

full_name: Submodule.fst_sup_snd
code: theorem fst_sup_snd : Submodule.fst R M M₂ ⊔ Submodule.snd R M M₂ = ⊤ 
goal: Submodule.fst R M M₂ ⊔ Submodule.snd R M M₂ = ⊤

full_name: Submodule.fst_inf_snd
code: theorem fst_inf_snd : Submodule.fst R M M₂ ⊓ Submodule.snd R M M₂ = ⊥ 
goal: Submodule.fst R M M₂ ⊓ Submodule.snd R M M₂ = ⊥

full_name: Submodule.le_prod_iff
code: theorem le_prod_iff {p₁ : Submodule R M} {p₂ : Submodule R M₂} {q : Submodule R (M × M₂)} :
    q ≤ p₁.prod p₂ ↔ map (LinearMap.fst R M M₂) q ≤ p₁ ∧ map (LinearMap.snd R M M₂) q ≤ p₂ 
goal: q ≤ p₁.prod p₂ ↔ Submodule.map (LinearMap.fst R M M₂) q ≤ p₁ ∧ Submodule.map (LinearMap.snd R M M₂) q ≤ p₂

full_name: Submodule.prod_le_iff
code: theorem prod_le_iff {p₁ : Submodule R M} {p₂ : Submodule R M₂} {q : Submodule R (M × M₂)} :
    p₁.prod p₂ ≤ q ↔ map (LinearMap.inl R M M₂) p₁ ≤ q ∧ map (LinearMap.inr R M M₂) p₂ ≤ q 
goal: p₁.prod p₂ ≤ q ↔ Submodule.map (LinearMap.inl R M M₂) p₁ ≤ q ∧ Submodule.map (LinearMap.inr R M M₂) p₂ ≤ q

full_name: Submodule.prod_eq_bot_iff
code: theorem prod_eq_bot_iff {p₁ : Submodule R M} {p₂ : Submodule R M₂} :
    p₁.prod p₂ = ⊥ ↔ p₁ = ⊥ ∧ p₂ = ⊥ 
goal: p₁.prod p₂ = ⊥ ↔ p₁ = ⊥ ∧ p₂ = ⊥

full_name: Submodule.prod_eq_top_iff
code: theorem prod_eq_top_iff {p₁ : Submodule R M} {p₂ : Submodule R M₂} :
    p₁.prod p₂ = ⊤ ↔ p₁ = ⊤ ∧ p₂ = ⊤ 
goal: p₁.prod p₂ = ⊤ ↔ p₁ = ⊤ ∧ p₂ = ⊤

full_name: LinearEquiv.prodComm_apply
code: /-- Product of modules is commutative up to linear isomorphism. -/
@[simps apply]
def prodComm (R M N : Type*) [Semiring R] [AddCommMonoid M] [AddCommMonoid N] [Module R M]
    [Module R N] : (M × N) ≃ₗ[R] N × M 
goal: ∀ (a : M × N), (LinearEquiv.prodComm R M N) a = a.swap

full_name: LinearEquiv.prodComm
code: /-- Product of modules is commutative up to linear isomorphism. -/
@[simps apply]
def prodComm (R M N : Type*) [Semiring R] [AddCommMonoid M] [AddCommMonoid N] [Module R M]
    [Module R N] : (M × N) ≃ₗ[R] N × M 
goal: (M × N) ≃ₗ[R] N × M

full_name: LinearEquiv.fst_comp_prodComm
code: theorem fst_comp_prodComm :
    (LinearMap.fst R M₂ M).comp (prodComm R M M₂).toLinearMap = (LinearMap.snd R M M₂) 
goal: LinearMap.fst R M₂ M ∘ₗ ↑(LinearEquiv.prodComm R M M₂) = LinearMap.snd R M M₂

full_name: LinearEquiv.snd_comp_prodComm
code: theorem snd_comp_prodComm :
    (LinearMap.snd R M₂ M).comp (prodComm R M M₂).toLinearMap = (LinearMap.fst R M M₂) 
goal: LinearMap.snd R M₂ M ∘ₗ ↑(LinearEquiv.prodComm R M M₂) = LinearMap.fst R M M₂

full_name: LinearEquiv.prodProdProdComm
code: /-- Four-way commutativity of `prod`. The name matches `mul_mul_mul_comm`. -/
@[simps apply]
def prodProdProdComm : ((M × M₂) × M₃ × M₄) ≃ₗ[R] (M × M₃) × M₂ × M₄ 
goal: ((M × M₂) × M₃ × M₄) ≃ₗ[R] (M × M₃) × M₂ × M₄

full_name: LinearEquiv.prodProdProdComm_apply
code: /-- Four-way commutativity of `prod`. The name matches `mul_mul_mul_comm`. -/
@[simps apply]
def prodProdProdComm : ((M × M₂) × M₃ × M₄) ≃ₗ[R] (M × M₃) × M₂ × M₄ 
goal: (LinearEquiv.prodProdProdComm R M M₂ M₃ M₄) mnmn = ((mnmn.1.1, mnmn.2.1), mnmn.1.2, mnmn.2.2)

full_name: LinearEquiv.prodProdProdComm_symm
code: @[simp]
theorem prodProdProdComm_symm :
    (prodProdProdComm R M M₂ M₃ M₄).symm = prodProdProdComm R M M₃ M₂ M₄ 
goal: (LinearEquiv.prodProdProdComm R M M₂ M₃ M₄).symm = LinearEquiv.prodProdProdComm R M M₃ M₂ M₄

full_name: LinearEquiv.prodProdProdComm_toAddEquiv
code: @[simp]
theorem prodProdProdComm_toAddEquiv :
    (prodProdProdComm R M M₂ M₃ M₄ : _ ≃+ _) = AddEquiv.prodProdProdComm M M₂ M₃ M₄ 
goal: ↑(LinearEquiv.prodProdProdComm R M M₂ M₃ M₄) = AddEquiv.prodProdProdComm M M₂ M₃ M₄

full_name: LinearEquiv.prod
code: /-- Product of linear equivalences; the maps come from `Equiv.prodCongr`. -/
protected def prod : (M × M₃) ≃ₗ[R] M₂ × M₄ 
goal: (M × M₃) ≃ₗ[R] M₂ × M₄

full_name: LinearEquiv.prod_symm
code: theorem prod_symm : (e₁.prod e₂).symm = e₁.symm.prod e₂.symm 
goal: (e₁.prod e₂).symm = e₁.symm.prod e₂.symm

full_name: LinearEquiv.prod_apply
code: @[simp]
theorem prod_apply (p) : e₁.prod e₂ p = (e₁ p.1, e₂ p.2) 
goal: (e₁.prod e₂) p = (e₁ p.1, e₂ p.2)

full_name: LinearEquiv.coe_prod
code: @[simp, norm_cast]
theorem coe_prod :
    (e₁.prod e₂ : M × M₃ →ₗ[R] M₂ × M₄) = (e₁ : M →ₗ[R] M₂).prodMap (e₂ : M₃ →ₗ[R] M₄) 
goal: ↑(e₁.prod e₂) = (↑e₁).prodMap ↑e₂

full_name: LinearEquiv.skewProd
code: /-- Equivalence given by a block lower diagonal matrix. `e₁` and `e₂` are diagonal square blocks,
  and `f` is a rectangular block below the diagonal. -/
protected def skewProd (f : M →ₗ[R] M₄) : (M × M₃) ≃ₗ[R] M₂ × M₄ 
goal: (M × M₃) ≃ₗ[R] M₂ × M₄

full_name: LinearEquiv.skewProd_apply
code: @[simp]
theorem skewProd_apply (f : M →ₗ[R] M₄) (x) : e₁.skewProd e₂ f x = (e₁ x.1, e₂ x.2 + f x.1) 
goal: (e₁.skewProd e₂ f) x = (e₁ x.1, e₂ x.2 + f x.1)

full_name: LinearEquiv.skewProd_symm_apply
code: @[simp]
theorem skewProd_symm_apply (f : M →ₗ[R] M₄) (x) :
    (e₁.skewProd e₂ f).symm x = (e₁.symm x.1, e₂.symm (x.2 - f (e₁.symm x.1))) 
goal: (e₁.skewProd e₂ f).symm x = (e₁.symm x.1, e₂.symm (x.2 - f (e₁.symm x.1)))

full_name: LinearMap.range_prod_eq
code: /-- If the union of the kernels `ker f` and `ker g` spans the domain, then the range of
`Prod f g` is equal to the product of `range f` and `range g`. -/
theorem range_prod_eq {f : M →ₗ[R] M₂} {g : M →ₗ[R] M₃} (h : ker f ⊔ ker g = ⊤) :
    range (prod f g) = (range f).prod (range g) 
goal: LinearMap.range (f.prod g) = (LinearMap.range f).prod (LinearMap.range g)

full_name: LinearMap.tunnelAux
code: /-- An auxiliary construction for `tunnel`.
The composition of `f`, followed by the isomorphism back to `K`,
followed by the inclusion of this submodule back into `M`. -/
@[deprecated (since := "2024-06-05")]
def tunnelAux (f : M × N →ₗ[R] M) (Kφ : ΣK : Submodule R M, K ≃ₗ[R] M) : M × N →ₗ[R] M 
goal: M × N →ₗ[R] M

full_name: LinearMap.tunnelAux_injective
code: @[deprecated (since := "2024-06-05")]
theorem tunnelAux_injective (f : M × N →ₗ[R] M) (i : Injective f)
    (Kφ : ΣK : Submodule R M, K ≃ₗ[R] M) : Injective (tunnelAux f Kφ) 
goal: Function.Injective ⇑(f.tunnelAux Kφ)

full_name: LinearMap.tunnel'
code: /-- Auxiliary definition for `tunnel`. -/
@[deprecated (since := "2024-06-05")]
def tunnel' (f : M × N →ₗ[R] M) (i : Injective f) : ℕ → ΣK : Submodule R M, K ≃ₗ[R] M
  
goal: ℕ → (K : Submodule R M) × ↥K ≃ₗ[R] M

full_name: LinearMap.tunnel
code: /-- Give an injective map `f : M × N →ₗ[R] M` we can find a nested sequence of submodules
all isomorphic to `M`.
-/
@[deprecated (since := "2024-06-05")]
def tunnel (f : M × N →ₗ[R] M) (i : Injective f) : ℕ →o (Submodule R M)ᵒᵈ 
goal: ℕ →o (Submodule R M)ᵒᵈ

full_name: LinearMap.tailing
code: /-- Give an injective map `f : M × N →ₗ[R] M` we can find a sequence of submodules
all isomorphic to `N`.
-/
@[deprecated (since := "2024-06-05")]
def tailing (f : M × N →ₗ[R] M) (i : Injective f) (n : ℕ) : Submodule R M 
goal: Submodule R M

full_name: LinearMap.tailingLinearEquiv
code: /-- Each `tailing f i n` is a copy of `N`. -/
@[deprecated (since := "2024-06-05")]
def tailingLinearEquiv (f : M × N →ₗ[R] M) (i : Injective f) (n : ℕ) : tailing f i n ≃ₗ[R] N 
goal: ↥(f.tailing i n) ≃ₗ[R] N

full_name: LinearMap.tailing_le_tunnel
code: @[deprecated (since := "2024-06-05")]
theorem tailing_le_tunnel (f : M × N →ₗ[R] M) (i : Injective f) (n : ℕ) :
    tailing f i n ≤ OrderDual.ofDual (α := Submodule R M) (tunnel f i n) 
goal: f.tailing i n ≤ OrderDual.ofDual ((f.tunnel i) n)

full_name: LinearMap.tailing_disjoint_tunnel_succ
code: @[deprecated (since := "2024-06-05")]
theorem tailing_disjoint_tunnel_succ (f : M × N →ₗ[R] M) (i : Injective f) (n : ℕ) :
    Disjoint (tailing f i n) (OrderDual.ofDual (α := Submodule R M) <| tunnel f i (n + 1)) 
goal: Disjoint (f.tailing i n) (OrderDual.ofDual ((f.tunnel i) (n + 1)))

full_name: LinearMap.tailing_sup_tunnel_succ_le_tunnel
code: @[deprecated (since := "2024-06-05")]
theorem tailing_sup_tunnel_succ_le_tunnel (f : M × N →ₗ[R] M) (i : Injective f) (n : ℕ) :
    tailing f i n ⊔ (OrderDual.ofDual (α := Submodule R M) $ tunnel f i (n + 1)) ≤
      (OrderDual.ofDual (α := Submodule R M) <| tunnel f i n) 
goal: f.tailing i n ⊔ OrderDual.ofDual ((f.tunnel i) (n + 1)) ≤ OrderDual.ofDual ((f.tunnel i) n)

full_name: LinearMap.tailings
code: /-- The supremum of all the copies of `N` found inside the tunnel. -/
@[deprecated (since := "2024-06-05")]
def tailings (f : M × N →ₗ[R] M) (i : Injective f) : ℕ → Submodule R M 
goal: ℕ → Submodule R M

full_name: LinearMap.tailings_zero
code: @[simp, deprecated (since := "2024-06-05")]
theorem tailings_zero (f : M × N →ₗ[R] M) (i : Injective f) : tailings f i 0 = tailing f i 0 
goal: f.tailings i 0 = f.tailing i 0

full_name: LinearMap.tailings_succ
code: @[simp, deprecated (since := "2024-06-05")]
theorem tailings_succ (f : M × N →ₗ[R] M) (i : Injective f) (n : ℕ) :
    tailings f i (n + 1) = tailings f i n ⊔ tailing f i (n + 1) 
goal: f.tailings i (n + 1) = f.tailings i n ⊔ f.tailing i (n + 1)

full_name: LinearMap.tailings_disjoint_tunnel
code: @[deprecated (since := "2024-06-05")]
theorem tailings_disjoint_tunnel (f : M × N →ₗ[R] M) (i : Injective f) (n : ℕ) :
    Disjoint (tailings f i n) (OrderDual.ofDual (α := Submodule R M) <| tunnel f i (n + 1)) 
goal: Disjoint (f.tailings i n) (OrderDual.ofDual ((f.tunnel i) (n + 1)))

full_name: LinearMap.tailings_disjoint_tailing
code: @[deprecated (since := "2024-06-05")]
theorem tailings_disjoint_tailing (f : M × N →ₗ[R] M) (i : Injective f) (n : ℕ) :
    Disjoint (tailings f i n) (tailing f i (n + 1)) 
goal: Disjoint (f.tailings i n) (f.tailing i (n + 1))

full_name: LinearMap.graph
code: /-- Graph of a linear map. -/
def graph : Submodule R (M × M₂) 
goal: Submodule R (M × M₂)

full_name: LinearMap.mem_graph_iff
code: @[simp]
theorem mem_graph_iff (x : M × M₂) : x ∈ f.graph ↔ x.2 = f x.1 
goal: x ∈ f.graph ↔ x.2 = f x.1

full_name: LinearMap.graph_eq_ker_coprod
code: theorem graph_eq_ker_coprod : g.graph = ker ((-g).coprod LinearMap.id) 
goal: g.graph = LinearMap.ker ((-g).coprod LinearMap.id)

full_name: LinearMap.graph_eq_range_prod
code: theorem graph_eq_range_prod : f.graph = range (LinearMap.id.prod f) 
goal: f.graph = LinearMap.range (LinearMap.id.prod f)