# Jordan-Hölder Theorem #

This file proves the Jordan Hölder theorem for a JordanHolderLattice, a class also defined in this file. Examples of JordanHolderLattice include Subgroup G if G is a group, and Submodule R M if M is an R-module. Using this approach the theorem need not be proved separately for both groups and modules, the proof in this file can be applied to both.

## Main definitions #

The main definitions in this file are JordanHolderLattice and CompositionSeries, and the relation Equivalent on CompositionSeries

A JordanHolderLattice is the class for which the Jordan Hölder theorem is proved. A Jordan Hölder lattice is a lattice equipped with a notion of maximality, IsMaximal, and a notion of isomorphism of pairs Iso. In the example of subgroups of a group, IsMaximal H K means that H is a maximal normal subgroup of K, and Iso (H₁, K₁) (H₂, K₂) means that the quotient H₁ / K₁ is isomorphic to the quotient H₂ / K₂. Iso must be symmetric and transitive and must satisfy the second isomorphism theorem Iso (H, H ⊔ K) (H ⊓ K, K).

A CompositionSeries X is a finite nonempty series of elements of the lattice X such that each element is maximal inside the next. The length of a CompositionSeries X is one less than the number of elements in the series. Note that there is no stipulation that a series start from the bottom of the lattice and finish at the top. For a composition series s, s.last is the largest element of the series, and s.head is the least element.

Two CompositionSeries X, s₁ and s₂ are equivalent if there is a bijection e : Fin s₁.length ≃ Fin s₂.length such that for any i, Iso (s₁ i, s₁ i.succ) (s₂ (e i), s₂ (e i.succ))

## Main theorems #

The main theorem is CompositionSeries.jordan_holder, which says that if two composition series have the same least element and the same largest element, then they are Equivalent.

## TODO #

Provide instances of JordanHolderLattice for subgroups, and potentially for modular lattices.

It is not entirely clear how this should be done. Possibly there should be no global instances of JordanHolderLattice, and the instances should only be defined locally in order to prove the Jordan-Hölder theorem for modules/groups and the API should be transferred because many of the theorems in this file will have stronger versions for modules. There will also need to be an API for mapping composition series across homomorphisms. It is also probably possible to provide an instance of JordanHolderLattice for any ModularLattice, and in this case the Jordan-Hölder theorem will say that there is a well defined notion of length of a modular lattice. However an instance of JordanHolderLattice for a modular lattice will not be able to contain the correct notion of isomorphism for modules, so a separate instance for modules will still be required and this will clash with the instance for modular lattices, and so at least one of these instances should not be a global instance.

[!NOTE] The previous paragraph indicates that the instance of JordanHolderLattice for submodules should be obtained via ModularLattice. This is not the case in mathlib4. See JordanHolderModule.instJordanHolderLattice.

class JordanHolderLattice (X : Type u) [] :

A JordanHolderLattice is the class for which the Jordan Hölder theorem is proved. A Jordan Hölder lattice is a lattice equipped with a notion of maximality, IsMaximal, and a notion of isomorphism of pairs Iso. In the example of subgroups of a group, IsMaximal H K means that H is a maximal normal subgroup of K, and Iso (H₁, K₁) (H₂, K₂) means that the quotient H₁ / K₁ is isomorphic to the quotient H₂ / K₂. Iso must be symmetric and transitive and must satisfy the second isomorphism theorem Iso (H, H ⊔ K) (H ⊓ K, K). Examples include Subgroup G if G is a group, and Submodule R M if M is an R-module.

• IsMaximal : XXProp
• lt_of_isMaximal : ∀ {x y : X}, x < y
• sup_eq_of_isMaximal : ∀ {x y z : X}, x yx y = z
• isMaximal_inf_left_of_isMaximal_sup : ∀ {x y : X},
• Iso : X × XX × XProp
• iso_symm : ∀ {x y : X × X},
• iso_trans : ∀ {x y z : X × X},
• second_iso : ∀ {x y : X}, JordanHolderLattice.Iso (x, x y) (x y, y)
Instances
theorem JordanHolderLattice.lt_of_isMaximal {X : Type u} [] [self : ] {x : X} {y : X} :
x < y
theorem JordanHolderLattice.sup_eq_of_isMaximal {X : Type u} [] [self : ] {x : X} {y : X} {z : X} :
x yx y = z
theorem JordanHolderLattice.isMaximal_inf_left_of_isMaximal_sup {X : Type u} [] [self : ] {x : X} {y : X} :
theorem JordanHolderLattice.iso_symm {X : Type u} [] [self : ] {x : X × X} {y : X × X} :
theorem JordanHolderLattice.iso_trans {X : Type u} [] [self : ] {x : X × X} {y : X × X} {z : X × X} :
theorem JordanHolderLattice.second_iso {X : Type u} [] [self : ] {x : X} {y : X} :
JordanHolderLattice.Iso (x, x y) (x y, y)
theorem JordanHolderLattice.isMaximal_inf_right_of_isMaximal_sup {X : Type u} [] {x : X} {y : X} (hxz : ) (hyz : ) :
theorem JordanHolderLattice.isMaximal_of_eq_inf {X : Type u} [] (x : X) (b : X) {a : X} {y : X} (ha : x y = a) (hxy : x y) (hxb : ) (hyb : ) :
theorem JordanHolderLattice.second_iso_of_eq {X : Type u} [] {x : X} {y : X} {a : X} {b : X} (hm : ) (ha : x y = a) (hb : x y = b) :
theorem JordanHolderLattice.IsMaximal.iso_refl {X : Type u} [] {x : X} {y : X} (h : ) :
@[reducible, inline]
abbrev CompositionSeries (X : Type u) [] :

A CompositionSeries X is a finite nonempty series of elements of a JordanHolderLattice such that each element is maximal inside the next. The length of a CompositionSeries X is one less than the number of elements in the series. Note that there is no stipulation that a series start from the bottom of the lattice and finish at the top. For a composition series s, s.last is the largest element of the series, and s.head is the least element.

Equations
Instances For
theorem CompositionSeries.lt_succ {X : Type u} [] (s : ) (i : Fin s.length) :
s.toFun i.castSucc < s.toFun i.succ
theorem CompositionSeries.strictMono {X : Type u} [] (s : ) :
StrictMono s.toFun
theorem CompositionSeries.injective {X : Type u} [] (s : ) :
@[simp]
theorem CompositionSeries.inj {X : Type u} [] (s : ) {i : Fin s.length.succ} {j : Fin s.length.succ} :
s.toFun i = s.toFun j i = j
theorem CompositionSeries.total {X : Type u} [] {s : } {x : X} {y : X} (hx : x s) (hy : y s) :
x y y x
theorem CompositionSeries.toList_sorted {X : Type u} [] (s : ) :
List.Sorted (fun (x x_1 : X) => x < x_1) ()
theorem CompositionSeries.toList_nodup {X : Type u} [] (s : ) :
().Nodup
theorem CompositionSeries.ext {X : Type u} [] {s₁ : } {s₂ : } (h : ∀ (x : X), x s₁ x s₂) :
s₁ = s₂

Two CompositionSeries are equal if they have the same elements. See also ext_fun.

@[simp]
theorem CompositionSeries.le_last {X : Type u} [] {s : } (i : Fin (s.length + 1)) :
s.toFun i
theorem CompositionSeries.le_last_of_mem {X : Type u} [] {s : } {x : X} (hx : x s) :
@[simp]
theorem CompositionSeries.head_le {X : Type u} [] {s : } (i : Fin (s.length + 1)) :
s.toFun i
theorem CompositionSeries.head_le_of_mem {X : Type u} [] {s : } {x : X} (hx : x s) :
theorem CompositionSeries.last_eraseLast_le {X : Type u} [] (s : ) :
.last
theorem CompositionSeries.mem_eraseLast_of_ne_of_mem {X : Type u} [] {s : } {x : X} (hx : ) (hxs : x s) :
theorem CompositionSeries.mem_eraseLast {X : Type u} [] {s : } {x : X} (h : 0 < s.length) :
x s
theorem CompositionSeries.lt_last_of_mem_eraseLast {X : Type u} [] {s : } {x : X} (h : 0 < s.length) (hx : ) :
theorem CompositionSeries.isMaximal_eraseLast_last {X : Type u} [] {s : } (h : 0 < s.length) :
theorem CompositionSeries.eq_snoc_eraseLast {X : Type u} [] {s : } (h : 0 < s.length) :
s = .snoc ()
@[simp]
theorem CompositionSeries.snoc_eraseLast_last {X : Type u} [] {s : } (h : ) :
.snoc () h = s
def CompositionSeries.Equivalent {X : Type u} [] (s₁ : ) (s₂ : ) :

Two CompositionSeries X, s₁ and s₂ are equivalent if there is a bijection e : Fin s₁.length ≃ Fin s₂.length such that for any i, Iso (s₁ i) (s₁ i.succ) (s₂ (e i), s₂ (e i.succ))

Equations
• One or more equations did not get rendered due to their size.
Instances For
theorem CompositionSeries.Equivalent.refl {X : Type u} [] (s : ) :
s.Equivalent s
theorem CompositionSeries.Equivalent.symm {X : Type u} [] {s₁ : } {s₂ : } (h : s₁.Equivalent s₂) :
s₂.Equivalent s₁
theorem CompositionSeries.Equivalent.trans {X : Type u} [] {s₁ : } {s₂ : } {s₃ : } (h₁ : s₁.Equivalent s₂) (h₂ : s₂.Equivalent s₃) :
s₁.Equivalent s₃
theorem CompositionSeries.Equivalent.smash {X : Type u} [] {s₁ : } {s₂ : } {t₁ : } {t₂ : } (hs : ) (ht : ) (h₁ : s₁.Equivalent t₁) (h₂ : s₂.Equivalent t₂) :
theorem CompositionSeries.Equivalent.snoc {X : Type u} [] {s₁ : } {s₂ : } {x₁ : X} {x₂ : X} {hsat₁ : } {hsat₂ : } (hequiv : s₁.Equivalent s₂) (hlast : JordanHolderLattice.Iso (, x₁) (, x₂)) :
CompositionSeries.Equivalent (RelSeries.snoc s₁ x₁ hsat₁) (RelSeries.snoc s₂ x₂ hsat₂)
theorem CompositionSeries.Equivalent.length_eq {X : Type u} [] {s₁ : } {s₂ : } (h : s₁.Equivalent s₂) :
s₁.length = s₂.length
theorem CompositionSeries.Equivalent.snoc_snoc_swap {X : Type u} [] {s : } {x₁ : X} {x₂ : X} {y₁ : X} {y₂ : X} {hsat₁ : } {hsat₂ : } {hsaty₁ : JordanHolderLattice.IsMaximal (RelSeries.snoc s x₁ hsat₁).last y₁} {hsaty₂ : JordanHolderLattice.IsMaximal (RelSeries.snoc s x₂ hsat₂).last y₂} (hr₁ : JordanHolderLattice.Iso (, x₁) (x₂, y₂)) (hr₂ : JordanHolderLattice.Iso (x₁, y₁) (, x₂)) :
CompositionSeries.Equivalent ((RelSeries.snoc s x₁ hsat₁).snoc y₁ hsaty₁) ((RelSeries.snoc s x₂ hsat₂).snoc y₂ hsaty₂)
theorem CompositionSeries.length_eq_zero_of_head_eq_head_of_last_eq_last_of_length_eq_zero {X : Type u} [] {s₁ : } {s₂ : } (hb : ) (ht : ) (hs₁ : s₁.length = 0) :
s₂.length = 0
theorem CompositionSeries.length_pos_of_head_eq_head_of_last_eq_last_of_length_pos {X : Type u} [] {s₁ : } {s₂ : } (hb : ) (ht : ) :
0 < s₁.length0 < s₂.length
theorem CompositionSeries.eq_of_head_eq_head_of_last_eq_last_of_length_eq_zero {X : Type u} [] {s₁ : } {s₂ : } (hb : ) (ht : ) (hs₁0 : s₁.length = 0) :
s₁ = s₂
theorem CompositionSeries.exists_last_eq_snoc_equivalent {X : Type u} [] (s : ) (x : X) (hm : ) (hb : ) :
∃ (t : ), t.length + 1 = s.length ∃ (htx : ), s.Equivalent ()

Given a CompositionSeries, s, and an element x such that x is maximal inside s.last there is a series, t, such that t.last = x, t.head = s.head and snoc t s.last _ is equivalent to s.

theorem CompositionSeries.jordan_holder {X : Type u} [] (s₁ : ) (s₂ : ) (hb : ) (ht : ) :
s₁.Equivalent s₂

The Jordan-Hölder theorem, stated for any JordanHolderLattice. If two composition series start and finish at the same place, they are equivalent.