# Hom orthogonal families. #

A family of objects in a category with zero morphisms is "hom orthogonal" if the only morphism between distinct objects is the zero morphism.

We show that in any category with zero morphisms and finite biproducts, a morphism between biproducts drawn from a hom orthogonal family s : ι → C can be decomposed into a block diagonal matrix with entries in the endomorphism rings of the s i.

When the category is preadditive, this decomposition is an additive equivalence, and intertwines composition and matrix multiplication. When the category is R-linear, the decomposition is an R-linear equivalence.

If every object in the hom orthogonal family has an endomorphism ring with invariant basis number (e.g. if each object in the family is simple, so its endomorphism ring is a division ring, or otherwise if each endomorphism ring is commutative), then decompositions of an object as a biproduct of the family have uniquely defined multiplicities. We state this as:

theorem HomOrthogonal.equiv_of_iso (o : HomOrthogonal s) {f : α → ι} {g : β → ι}
(i : (⨁ fun a => s (f a)) ≅ ⨁ fun b => s (g b)) : ∃ e : α ≃ β, ∀ a, g (e a) = f a


This is preliminary to defining semisimple categories.

def CategoryTheory.HomOrthogonal {C : Type u} {ι : Type u_1} (s : ιC) :

A family of objects is "hom orthogonal" if there is at most one morphism between distinct objects.

(In a category with zero morphisms, that must be the zero morphism.)

Equations
Instances For
theorem CategoryTheory.HomOrthogonal.eq_zero {C : Type u} {ι : Type u_1} {s : ιC} (o : ) {i : ι} {j : ι} (w : i j) (f : s i s j) :
f = 0
@[simp]
theorem CategoryTheory.HomOrthogonal.matrixDecomposition_apply {C : Type u} {ι : Type u_1} {s : ιC} (o : ) {α : Type} {β : Type} [] [] {f : αι} {g : βι} (z : ( fun (a : α) => s (f a)) fun (b : β) => s (g b)) (i : ι) (j : (g ⁻¹' {i})) (k : (f ⁻¹' {i})) :
o.matrixDecomposition z i j k =
@[simp]
theorem CategoryTheory.HomOrthogonal.matrixDecomposition_symm_apply {C : Type u} {ι : Type u_1} {s : ιC} (o : ) {α : Type} {β : Type} [] [] {f : αι} {g : βι} (z : (i : ι) → Matrix ((g ⁻¹' {i})) ((f ⁻¹' {i})) (CategoryTheory.End (s i))) :
o.matrixDecomposition.symm z = CategoryTheory.Limits.biproduct.matrix fun (j : α) (k : β) => if h : f j = g k then CategoryTheory.CategoryStruct.comp (z (f j) k, j, ) else 0
noncomputable def CategoryTheory.HomOrthogonal.matrixDecomposition {C : Type u} {ι : Type u_1} {s : ιC} (o : ) {α : Type} {β : Type} [] [] {f : αι} {g : βι} :
(( fun (a : α) => s (f a)) fun (b : β) => s (g b)) ((i : ι) → Matrix ((g ⁻¹' {i})) ((f ⁻¹' {i})) (CategoryTheory.End (s i)))

Morphisms between two direct sums over a hom orthogonal family s : ι → C are equivalent to block diagonal matrices, with blocks indexed by ι, and matrix entries in i-th block living in the endomorphisms of s i.

Equations
• One or more equations did not get rendered due to their size.
Instances For
@[simp]
theorem CategoryTheory.HomOrthogonal.matrixDecompositionAddEquiv_apply {C : Type u} {ι : Type u_1} {s : ιC} (o : ) {α : Type} {β : Type} [] [] {f : αι} {g : βι} (z : ( fun (a : α) => s ((fun (a : α) => f a) a)) fun (b : β) => s ((fun (b : β) => g b) b)) (i : ι) (j : ((fun (b : β) => g b) ⁻¹' {i})) (k : ((fun (a : α) => f a) ⁻¹' {i})) :
o.matrixDecompositionAddEquiv z i j k =
@[simp]
theorem CategoryTheory.HomOrthogonal.matrixDecompositionAddEquiv_symm_apply {C : Type u} {ι : Type u_1} {s : ιC} (o : ) {α : Type} {β : Type} [] [] {f : αι} {g : βι} (z : (i : ι) → Matrix (((fun (b : β) => g b) ⁻¹' {i})) (((fun (a : α) => f a) ⁻¹' {i})) (CategoryTheory.End (s i))) :
o.matrixDecompositionAddEquiv.symm z = CategoryTheory.Limits.biproduct.matrix fun (j : α) (k : β) => if h : f j = g k then CategoryTheory.CategoryStruct.comp (z (f j) k, j, ) else 0
noncomputable def CategoryTheory.HomOrthogonal.matrixDecompositionAddEquiv {C : Type u} {ι : Type u_1} {s : ιC} (o : ) {α : Type} {β : Type} [] [] {f : αι} {g : βι} :
(( fun (a : α) => s (f a)) fun (b : β) => s (g b)) ≃+ ((i : ι) → Matrix ((g ⁻¹' {i})) ((f ⁻¹' {i})) (CategoryTheory.End (s i)))

HomOrthogonal.matrixDecomposition as an additive equivalence.

Equations
• o.matrixDecompositionAddEquiv = let __src := o.matrixDecomposition; { toEquiv := __src, map_add' := }
Instances For
@[simp]
theorem CategoryTheory.HomOrthogonal.matrixDecomposition_id {C : Type u} {ι : Type u_1} {s : ιC} (o : ) {α : Type} [] {f : αι} (i : ι) :
o.matrixDecomposition (CategoryTheory.CategoryStruct.id ( fun (a : α) => s (f a))) i = 1
theorem CategoryTheory.HomOrthogonal.matrixDecomposition_comp {C : Type u} {ι : Type u_1} {s : ιC} (o : ) {α : Type} {β : Type} {γ : Type} [] [] [] {f : αι} {g : βι} {h : γι} (z : ( fun (a : α) => s (f a)) fun (b : β) => s (g b)) (w : ( fun (b : β) => s (g b)) fun (c : γ) => s (h c)) (i : ι) :
o.matrixDecomposition i = o.matrixDecomposition w i * o.matrixDecomposition z i
@[simp]
theorem CategoryTheory.HomOrthogonal.matrixDecompositionLinearEquiv_apply {C : Type u} {ι : Type u_1} {s : ιC} {R : Type u_2} [] [] (o : ) {α : Type} {β : Type} [] [] {f : αι} {g : βι} :
∀ (a : ( fun (a : α) => s (f a)) fun (b : β) => s (g b)) (i : ι), o.matrixDecompositionLinearEquiv a i = o.matrixDecompositionAddEquiv.toFun a i
@[simp]
theorem CategoryTheory.HomOrthogonal.matrixDecompositionLinearEquiv_symm_apply {C : Type u} {ι : Type u_1} {s : ιC} {R : Type u_2} [] [] (o : ) {α : Type} {β : Type} [] [] {f : αι} {g : βι} :
∀ (a : (i : ι) → Matrix (((fun (b : β) => g b) ⁻¹' {i})) (((fun (a : α) => f a) ⁻¹' {i})) (CategoryTheory.End (s i))), o.matrixDecompositionLinearEquiv.symm a = o.matrixDecompositionAddEquiv.invFun a
noncomputable def CategoryTheory.HomOrthogonal.matrixDecompositionLinearEquiv {C : Type u} {ι : Type u_1} {s : ιC} {R : Type u_2} [] [] (o : ) {α : Type} {β : Type} [] [] {f : αι} {g : βι} :
(( fun (a : α) => s (f a)) fun (b : β) => s (g b)) ≃ₗ[R] (i : ι) → Matrix ((g ⁻¹' {i})) ((f ⁻¹' {i})) (CategoryTheory.End (s i))

HomOrthogonal.MatrixDecomposition as an R-linear equivalence.

Equations
• o.matrixDecompositionLinearEquiv = let __src := o.matrixDecompositionAddEquiv; { toFun := __src.toFun, map_add' := , map_smul' := , invFun := __src.invFun, left_inv := , right_inv := }
Instances For

The hypothesis that End (s i) has invariant basis number is automatically satisfied if s i is simple (as then End (s i) is a division ring).

theorem CategoryTheory.HomOrthogonal.equiv_of_iso {C : Type u} {ι : Type u_1} {s : ιC} [∀ (i : ι), ] (o : ) {α : Type} {β : Type} [] [] {f : αι} {g : βι} (i : ( fun (a : α) => s (f a)) fun (b : β) => s (g b)) :
∃ (e : α β), ∀ (a : α), g (e a) = f a

Given a hom orthogonal family s : ι → C for which each End (s i) is a ring with invariant basis number (e.g. if each s i is simple), if two direct sums over s are isomorphic, then they have the same multiplicities.