fact stringlengths 6 3.84k | type stringclasses 11 values | library stringclasses 32 values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
@[simps]
prod (f : M →ₗ[R] M₂) (g : M →ₗ[R] M₃) : M →ₗ[R] M₂ × M₃ where
toFun := Pi.prod f g
map_add' x y := by simp only [Pi.prod, Prod.mk_add_mk, map_add]
map_smul' c x := by simp only [Pi.prod, Prod.smul_mk, map_smul, RingHom.id_apply] | def | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prod | The prod of two linear maps is a linear map. |
coe_prod (f : M →ₗ[R] M₂) (g : M →ₗ[R] M₃) : ⇑(f.prod g) = Pi.prod f g :=
rfl
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | coe_prod | null |
fst_prod (f : M →ₗ[R] M₂) (g : M →ₗ[R] M₃) : (fst R M₂ M₃).comp (prod f g) = f := rfl
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | fst_prod | null |
snd_prod (f : M →ₗ[R] M₂) (g : M →ₗ[R] M₃) : (snd R M₂ M₃).comp (prod f g) = g := rfl
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | snd_prod | null |
pair_fst_snd : prod (fst R M M₂) (snd R M M₂) = LinearMap.id := rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | pair_fst_snd | null |
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) :=
rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prod_comp | null |
@[simps]
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₃ where
toFun f := f.1.prod f.2
invFun f := ((fst _ _ _).comp f, (snd _ _ _).comp f)
map_add' _ _ := rfl
map_smul' _ _ := rfl | def | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prodEquiv | 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. |
inl : M →ₗ[R] M × M₂ :=
prod LinearMap.id 0 | def | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | inl | The left injection into a product is a linear map. |
inr : M₂ →ₗ[R] M × M₂ :=
prod 0 LinearMap.id | def | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | inr | The right injection into a product is a linear map. |
range_inl : range (inl R M M₂) = ker (snd R M M₂) := by
ext x
simp only [mem_ker, mem_range]
constructor
· rintro ⟨y, rfl⟩
rfl
· intro h
exact ⟨x.fst, Prod.ext rfl h.symm⟩ | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | range_inl | null |
ker_snd : ker (snd R M M₂) = range (inl R M M₂) :=
Eq.symm <| range_inl R M M₂ | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | ker_snd | null |
range_inr : range (inr R M M₂) = ker (fst R M M₂) := by
ext x
simp only [mem_ker, mem_range]
constructor
· rintro ⟨y, rfl⟩
rfl
· intro h
exact ⟨x.snd, Prod.ext h.symm rfl⟩ | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | range_inr | null |
ker_fst : ker (fst R M M₂) = range (inr R M M₂) :=
Eq.symm <| range_inr R M M₂
@[simp] theorem fst_comp_inl : fst R M M₂ ∘ₗ inl R M M₂ = id := rfl
@[simp] theorem snd_comp_inl : snd R M M₂ ∘ₗ inl R M M₂ = 0 := rfl
@[simp] theorem fst_comp_inr : fst R M M₂ ∘ₗ inr R M M₂ = 0 := rfl
@[simp] theorem snd_comp_inr : snd R M M₂ ∘ₗ inr R M M₂ = id := rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | ker_fst | null |
@[simp]
coe_inl : (inl R M M₂ : M → M × M₂) = fun x => (x, 0) :=
rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | coe_inl | null |
inl_apply (x : M) : inl R M M₂ x = (x, 0) :=
rfl
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | inl_apply | null |
coe_inr : (inr R M M₂ : M₂ → M × M₂) = Prod.mk 0 :=
rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | coe_inr | null |
inr_apply (x : M₂) : inr R M M₂ x = (0, x) :=
rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | inr_apply | null |
inl_eq_prod : inl R M M₂ = prod LinearMap.id 0 :=
rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | inl_eq_prod | null |
inr_eq_prod : inr R M M₂ = prod 0 LinearMap.id :=
rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | inr_eq_prod | null |
inl_injective : Function.Injective (inl R M M₂) := fun _ => by simp | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | inl_injective | null |
inr_injective : Function.Injective (inr R M M₂) := fun _ => by simp | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | inr_injective | null |
coprod (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₃) : M × M₂ →ₗ[R] M₃ :=
f.comp (fst _ _ _) + g.comp (snd _ _ _)
@[simp] | def | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | coprod | The coprod function `x : M × M₂ ↦ f x.1 + g x.2` is a linear map. |
coprod_apply (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₃) (x : M × M₂) :
coprod f g x = f x.1 + g x.2 :=
rfl
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | coprod_apply | null |
coprod_inl (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₃) : (coprod f g).comp (inl R M M₂) = f := by
ext; simp only [map_zero, add_zero, coprod_apply, inl_apply, comp_apply]
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | coprod_inl | null |
coprod_inr (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₃) : (coprod f g).comp (inr R M M₂) = g := by
ext; simp only [map_zero, coprod_apply, inr_apply, zero_add, comp_apply]
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | coprod_inr | null |
coprod_inl_inr : coprod (inl R M M₂) (inr R M M₂) = LinearMap.id := by
ext <;>
simp only [Prod.mk_add_mk, add_zero, id_apply, coprod_apply, inl_apply, inr_apply, zero_add] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | coprod_inl_inr | null |
coprod_zero_left (g : M₂ →ₗ[R] M₃) : (0 : M →ₗ[R] M₃).coprod g = g.comp (snd R M M₂) :=
zero_add _ | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | coprod_zero_left | null |
coprod_zero_right (f : M →ₗ[R] M₃) : f.coprod (0 : M₂ →ₗ[R] M₃) = f.comp (fst R M M₂) :=
add_zero _ | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | coprod_zero_right | null |
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₂) :=
ext fun x => f.map_add (g₁ x.1) (g₂ x.2) | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | comp_coprod | null |
fst_eq_coprod : fst R M M₂ = coprod LinearMap.id 0 := by ext; simp | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | fst_eq_coprod | null |
snd_eq_coprod : snd R M M₂ = coprod 0 LinearMap.id := by ext; simp
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | snd_eq_coprod | null |
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' :=
rfl
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | coprod_comp_prod | null |
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 :=
SetLike.coe_injective <| by
simp only [LinearMap.coprod_apply, Submodule.coe_sup, Submodule.map_coe]
rw [← Set.image2_add, Set.image2_image_left, Set.image2_image_right]
exact Set.image_prod fun m m₂ => f m + g m₂
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | coprod_map_prod | null |
coprod_comp_inl_inr (f : M × M₂ →ₗ[R] M₃) :
(f.comp (inl R M M₂)).coprod (f.comp (inr R M M₂)) = f := by
rw [← comp_coprod, coprod_inl_inr, comp_id] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | coprod_comp_inl_inr | null |
@[simps]
coprodEquiv [Module S M₃] [SMulCommClass R S M₃] :
((M →ₗ[R] M₃) × (M₂ →ₗ[R] M₃)) ≃ₗ[S] M × M₂ →ₗ[R] M₃ where
toFun f := f.1.coprod f.2
invFun f := (f.comp (inl _ _ _), f.comp (inr _ _ _))
left_inv f := by simp only [coprod_inl, coprod_inr]
right_inv f := by simp only [← comp_coprod, comp_id, coprod_inl_inr]
map_add' a b := by
ext
simp only [Prod.snd_add, add_apply, coprod_apply, Prod.fst_add, add_add_add_comm]
map_smul' r a := by
dsimp
ext
simp only [smul_add, smul_apply, coprod_apply] | def | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | coprodEquiv | 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. |
prod_ext_iff {f g : M × M₂ →ₗ[R] M₃} :
f = g ↔ f.comp (inl _ _ _) = g.comp (inl _ _ _) ∧ f.comp (inr _ _ _) = g.comp (inr _ _ _) :=
(coprodEquiv ℕ).symm.injective.eq_iff.symm.trans Prod.ext_iff | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prod_ext_iff | null |
@[ext 1100]
prod_ext {f g : M × M₂ →ₗ[R] M₃} (hl : f.comp (inl _ _ _) = g.comp (inl _ _ _))
(hr : f.comp (inr _ _ _) = g.comp (inr _ _ _)) : f = g :=
prod_ext_iff.2 ⟨hl, hr⟩ | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prod_ext | 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]. |
prodMap (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₄) : M × M₂ →ₗ[R] M₃ × M₄ :=
(f.comp (fst R M M₂)).prod (g.comp (snd R M M₂)) | def | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prodMap | `Prod.map` of two linear maps. |
coe_prodMap (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₄) : ⇑(f.prodMap g) = Prod.map f g :=
rfl
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | coe_prodMap | null |
prodMap_apply (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₄) (x) : f.prodMap g x = (f x.1, g x.2) :=
rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prodMap_apply | null |
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) :=
SetLike.coe_injective <| Set.preimage_prod_map_prod f g _ _ | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prodMap_comap_prod | null |
ker_prodMap (f : M →ₗ[R] M₂) (g : M₃ →ₗ[R] M₄) :
ker (LinearMap.prodMap f g) = Submodule.prod (ker f) (ker g) := by
dsimp only [ker]
rw [← prodMap_comap_prod, Submodule.prod_bot]
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | ker_prodMap | null |
prodMap_id : (id : M →ₗ[R] M).prodMap (id : M₂ →ₗ[R] M₂) = id :=
rfl
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prodMap_id | null |
prodMap_one : (1 : M →ₗ[R] M).prodMap (1 : M₂ →ₗ[R] M₂) = 1 :=
rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prodMap_one | null |
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₁₂) :=
rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prodMap_comp | null |
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₁₂) :=
rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prodMap_mul | null |
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₂ :=
rfl
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prodMap_add | null |
prodMap_zero : (0 : M →ₗ[R] M₂).prodMap (0 : M₃ →ₗ[R] M₄) = 0 :=
rfl
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prodMap_zero | null |
prodMap_smul [DistribMulAction S M₃] [DistribMulAction 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 :=
rfl
variable (R M M₂ M₃ M₄) | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prodMap_smul | null |
@[simps]
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₄ where
toFun f := prodMap f.1 f.2
map_add' _ _ := rfl
map_smul' _ _ := rfl | def | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prodMapLinear | `LinearMap.prodMap` as a `LinearMap` |
@[simps]
prodMapRingHom : (M →ₗ[R] M) × (M₂ →ₗ[R] M₂) →+* M × M₂ →ₗ[R] M × M₂ where
toFun f := prodMap f.1 f.2
map_one' := prodMap_one
map_zero' := rfl
map_add' _ _ := rfl
map_mul' _ _ := rfl
variable {R M M₂ M₃ M₄} | def | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prodMapRingHom | `LinearMap.prodMap` as a `RingHom` |
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₂ :=
Prod.ext rfl (by simp) | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | inl_map_mul | null |
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₂ :=
Prod.ext (by simp) rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | inr_map_mul | null |
@[simps!]
prodMapAlgHom : Module.End R M × Module.End R M₂ →ₐ[R] Module.End R (M × M₂) :=
{ prodMapRingHom R M M₂ with commutes' := fun _ => rfl } | def | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prodMapAlgHom | `LinearMap.prodMap` as an `AlgHom` |
range_coprod (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₃) : range (f.coprod g) = range f ⊔ range g :=
Submodule.ext fun x => by simp [mem_sup] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | range_coprod | null |
isCompl_range_inl_inr : IsCompl (range <| inl R M M₂) (range <| inr R M M₂) := by
constructor
· rw [disjoint_def]
rintro ⟨_, _⟩ ⟨x, hx⟩ ⟨y, hy⟩
simp only [Prod.ext_iff, inl_apply, inr_apply] at hx hy ⊢
exact ⟨hy.1.symm, hx.2.symm⟩
· rw [codisjoint_iff_le_sup]
rintro ⟨x, y⟩ -
simp only [mem_sup, mem_range]
refine ⟨(x, 0), ⟨x, rfl⟩, (0, y), ⟨y, rfl⟩, ?_⟩
simp | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | isCompl_range_inl_inr | null |
sup_range_inl_inr : (range <| inl R M M₂) ⊔ (range <| inr R M M₂) = ⊤ :=
IsCompl.sup_eq_top isCompl_range_inl_inr | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | sup_range_inl_inr | null |
disjoint_inl_inr : Disjoint (range <| inl R M M₂) (range <| inr R M M₂) := by
simp +contextual [disjoint_def, @eq_comm M 0] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | disjoint_inl_inr | null |
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 :=
coprod_map_prod f g p q | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | map_coprod_prod | null |
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 :=
Submodule.ext fun _x => Iff.rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | comap_prod_prod | null |
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₂) :=
Submodule.ext fun _x => Iff.rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prod_eq_inf_comap | null |
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₂) := by
rw [← map_coprod_prod, coprod_inl_inr, map_id] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prod_eq_sup_map | null |
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) := by
rw [span_union, prod_eq_sup_map, ← span_image, ← span_image]
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | span_inl_union_inr | null |
ker_prod (f : M →ₗ[R] M₂) (g : M →ₗ[R] M₃) : ker (prod f g) = ker f ⊓ ker g := by
rw [ker, ← prod_bot, comap_prod_prod]; rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | ker_prod | null |
range_prod_le (f : M →ₗ[R] M₂) (g : M →ₗ[R] M₃) :
range (prod f g) ≤ (range f).prod (range g) := by
simp only [SetLike.le_def, prod_apply, mem_range, mem_prod, exists_imp]
rintro _ x rfl
exact ⟨⟨x, rfl⟩, ⟨x, rfl⟩⟩ | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | range_prod_le | null |
ker_prod_ker_le_ker_coprod {M₂ : Type*} [AddCommMonoid M₂] [Module R M₂] {M₃ : Type*}
[AddCommMonoid M₃] [Module R M₃] (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₃) :
(ker f).prod (ker g) ≤ ker (f.coprod g) := by
rintro ⟨y, z⟩
simp +contextual | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | ker_prod_ker_le_ker_coprod | null |
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) := by
apply le_antisymm _ (ker_prod_ker_le_ker_coprod f g)
rintro ⟨y, z⟩ h
simp only [mem_ker, mem_prod, coprod_apply] at h ⊢
have : f y ∈ (range f) ⊓ (range g) := by
simp only [true_and, mem_range, mem_inf, exists_apply_eq_apply]
use -z
rwa [eq_comm, map_neg, ← sub_eq_zero, sub_neg_eq_add]
rw [hd.eq_bot, mem_bot] at this
rw [this] at h
simpa [this] using h | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | ker_coprod_of_disjoint_range | null |
sup_eq_range (p q : Submodule R M) : p ⊔ q = range (p.subtype.coprod q.subtype) :=
Submodule.ext fun x => by simp [Submodule.mem_sup]
variable (p : Submodule R M) (q : Submodule R M₂)
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | sup_eq_range | null |
map_inl : p.map (inl R M M₂) = prod p ⊥ := by
ext ⟨x, y⟩
simp only [and_left_comm, eq_comm, mem_map, Prod.mk_inj, inl_apply, mem_bot, exists_eq_left',
mem_prod]
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | map_inl | null |
map_inr : q.map (inr R M M₂) = prod ⊥ q := by
ext ⟨x, y⟩; simp [and_left_comm, eq_comm, and_comm]
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | map_inr | null |
comap_fst : p.comap (fst R M M₂) = prod p ⊤ := by ext ⟨x, y⟩; simp
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | comap_fst | null |
comap_snd : q.comap (snd R M M₂) = prod ⊤ q := by ext ⟨x, y⟩; simp
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | comap_snd | null |
prod_comap_inl : (prod p q).comap (inl R M M₂) = p := by ext; simp
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prod_comap_inl | null |
prod_comap_inr : (prod p q).comap (inr R M M₂) = q := by ext; simp
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prod_comap_inr | null |
prod_map_fst : (prod p q).map (fst R M M₂) = p := by
ext x; simp [(⟨0, zero_mem _⟩ : ∃ x, x ∈ q)]
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prod_map_fst | null |
prod_map_snd : (prod p q).map (snd R M M₂) = q := by
ext x; simp [(⟨0, zero_mem _⟩ : ∃ x, x ∈ p)]
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prod_map_snd | null |
ker_inl : ker (inl R M M₂) = ⊥ := by rw [ker, ← prod_bot, prod_comap_inl]
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | ker_inl | null |
ker_inr : ker (inr R M M₂) = ⊥ := by rw [ker, ← prod_bot, prod_comap_inr]
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | ker_inr | null |
range_fst : range (fst R M M₂) = ⊤ := by rw [range_eq_map, ← prod_top, prod_map_fst]
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | range_fst | null |
range_snd : range (snd R M M₂) = ⊤ := by rw [range_eq_map, ← prod_top, prod_map_snd]
variable (R M M₂) | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | range_snd | null |
fst : Submodule R (M × M₂) :=
(⊥ : Submodule R M₂).comap (LinearMap.snd R M M₂) | def | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | fst | `M` as a submodule of `M × N`. |
@[simps]
fstEquiv : Submodule.fst R M M₂ ≃ₗ[R] M where
toFun x := x.1.1
invFun m := ⟨⟨m, 0⟩, by aesop⟩
map_add' := by simp
map_smul' := by simp
left_inv x := by aesop (add norm simp Submodule.fst)
right_inv x := by simp | def | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | fstEquiv | `M` as a submodule of `M × N` is isomorphic to `M`. |
fst_map_fst : (Submodule.fst R M M₂).map (LinearMap.fst R M M₂) = ⊤ := by
aesop | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | fst_map_fst | null |
fst_map_snd : (Submodule.fst R M M₂).map (LinearMap.snd R M M₂) = ⊥ := by
aesop (add simp fst) | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | fst_map_snd | null |
snd : Submodule R (M × M₂) :=
(⊥ : Submodule R M).comap (LinearMap.fst R M M₂) | def | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | snd | `N` as a submodule of `M × N`. |
@[simps]
sndEquiv : Submodule.snd R M M₂ ≃ₗ[R] M₂ where
toFun x := x.1.2
invFun n := ⟨⟨0, n⟩, by aesop⟩
map_add' := by simp
map_smul' := by simp
left_inv x := by aesop (add norm simp Submodule.snd) | def | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | sndEquiv | `N` as a submodule of `M × N` is isomorphic to `N`. |
snd_map_fst : (Submodule.snd R M M₂).map (LinearMap.fst R M M₂) = ⊥ := by
aesop (add simp snd) | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | snd_map_fst | null |
snd_map_snd : (Submodule.snd R M M₂).map (LinearMap.snd R M M₂) = ⊤ := by
aesop | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | snd_map_snd | null |
fst_sup_snd : Submodule.fst R M M₂ ⊔ Submodule.snd R M M₂ = ⊤ := by
rw [eq_top_iff]
rintro ⟨m, n⟩ -
rw [show (m, n) = (m, 0) + (0, n) by simp]
apply Submodule.add_mem (Submodule.fst R M M₂ ⊔ Submodule.snd R M M₂)
· exact Submodule.mem_sup_left (Submodule.mem_comap.mpr (by simp))
· exact Submodule.mem_sup_right (Submodule.mem_comap.mpr (by simp)) | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | fst_sup_snd | null |
fst_inf_snd : Submodule.fst R M M₂ ⊓ Submodule.snd R M M₂ = ⊥ := by
aesop | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | fst_inf_snd | null |
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₂ := by
constructor
· intro h
constructor
· rintro x ⟨⟨y1, y2⟩, ⟨hy1, rfl⟩⟩
exact (h hy1).1
· rintro x ⟨⟨y1, y2⟩, ⟨hy1, rfl⟩⟩
exact (h hy1).2
· rintro ⟨hH, hK⟩ ⟨x1, x2⟩ h
exact ⟨hH ⟨_, h, rfl⟩, hK ⟨_, h, rfl⟩⟩ | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | le_prod_iff | null |
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 := by
constructor
· intro h
constructor
· rintro _ ⟨x, hx, rfl⟩
apply h
exact ⟨hx, zero_mem p₂⟩
· rintro _ ⟨x, hx, rfl⟩
apply h
exact ⟨zero_mem p₁, hx⟩
· rintro ⟨hH, hK⟩ ⟨x1, x2⟩ ⟨h1, h2⟩
have h1' : (LinearMap.inl R _ _) x1 ∈ q := by
apply hH
simpa using h1
have h2' : (LinearMap.inr R _ _) x2 ∈ q := by
apply hK
simpa using h2
simpa using add_mem h1' h2' | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prod_le_iff | null |
prod_eq_bot_iff {p₁ : Submodule R M} {p₂ : Submodule R M₂} :
p₁.prod p₂ = ⊥ ↔ p₁ = ⊥ ∧ p₂ = ⊥ := by
simp only [eq_bot_iff, prod_le_iff, (gc_map_comap _).le_iff_le, comap_bot, ker_inl, ker_inr] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prod_eq_bot_iff | null |
prod_eq_top_iff {p₁ : Submodule R M} {p₂ : Submodule R M₂} :
p₁.prod p₂ = ⊤ ↔ p₁ = ⊤ ∧ p₂ = ⊤ := by
simp only [eq_top_iff, le_prod_iff, map_top, range_fst, range_snd] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prod_eq_top_iff | null |
@[simps apply]
prodComm (R M N : Type*) [Semiring R] [AddCommMonoid M] [AddCommMonoid N] [Module R M]
[Module R N] : (M × N) ≃ₗ[R] N × M :=
{ AddEquiv.prodComm with
toFun := Prod.swap
map_smul' := fun _r ⟨_m, _n⟩ => rfl } | def | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prodComm | Product of modules is commutative up to linear isomorphism. |
fst_comp_prodComm :
(LinearMap.fst R M₂ M).comp (prodComm R M M₂).toLinearMap = (LinearMap.snd R M M₂) := by
ext <;> simp | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | fst_comp_prodComm | null |
snd_comp_prodComm :
(LinearMap.snd R M₂ M).comp (prodComm R M M₂).toLinearMap = (LinearMap.fst R M M₂) := by
ext <;> simp | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | snd_comp_prodComm | null |
@[simps apply]
prodAssoc (R M₁ M₂ M₃ : Type*) [Semiring R]
[AddCommMonoid M₁] [AddCommMonoid M₂] [AddCommMonoid M₃]
[Module R M₁] [Module R M₂] [Module R M₃] : ((M₁ × M₂) × M₃) ≃ₗ[R] (M₁ × (M₂ × M₃)) :=
{ AddEquiv.prodAssoc with
map_smul' := fun _r ⟨_m, _n⟩ => rfl } | def | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | prodAssoc | Product of modules is associative up to linear isomorphism. |
fst_comp_prodAssoc :
(LinearMap.fst R M₁ (M₂ × M₃)).comp (prodAssoc R M₁ M₂ M₃).toLinearMap =
(LinearMap.fst R M₁ M₂).comp (LinearMap.fst R (M₁ × M₂) M₃) := by
ext <;> simp | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | fst_comp_prodAssoc | null |
snd_comp_prodAssoc :
(LinearMap.snd R M₁ (M₂ × M₃)).comp (prodAssoc R M₁ M₂ M₃).toLinearMap =
(LinearMap.snd R M₁ M₂).prodMap (LinearMap.id : M₃ →ₗ[R] M₃) := by
ext <;> simp | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | snd_comp_prodAssoc | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.