File: Mathlib/GroupTheory/SpecificGroups/Alternating.lean

full_name: alternatingGroup
code: /-- The alternating group on a finite type, realized as a subgroup of `Equiv.Perm`.
  For $A_n$, use `alternatingGroup (Fin n)`. -/
def alternatingGroup : Subgroup (Perm α) 
goal: Subgroup (Equiv.Perm α)

full_name: alternatingGroup.instFintype
code: instance alternatingGroup.instFintype : Fintype (alternatingGroup α) 
goal: Fintype ↥(alternatingGroup α)

full_name: instUniqueSubtypePermMemSubgroupAlternatingGroupOfSubsingleton
code: instance [Subsingleton α] : Unique (alternatingGroup α) 
goal: Unique ↥(alternatingGroup α)

full_name: alternatingGroup_eq_sign_ker
code: theorem alternatingGroup_eq_sign_ker : alternatingGroup α = sign.ker 
goal: alternatingGroup α = Equiv.Perm.sign.ker

full_name: Equiv.Perm.mem_alternatingGroup
code: @[simp]
theorem mem_alternatingGroup {f : Perm α} : f ∈ alternatingGroup α ↔ sign f = 1 
goal: f ∈ alternatingGroup α ↔ Equiv.Perm.sign f = 1

full_name: Equiv.Perm.prod_list_swap_mem_alternatingGroup_iff_even_length
code: theorem prod_list_swap_mem_alternatingGroup_iff_even_length {l : List (Perm α)}
    (hl : ∀ g ∈ l, IsSwap g) : l.prod ∈ alternatingGroup α ↔ Even l.length 
goal: l.prod ∈ alternatingGroup α ↔ Even l.length

full_name: Equiv.Perm.IsThreeCycle.mem_alternatingGroup
code: theorem IsThreeCycle.mem_alternatingGroup {f : Perm α} (h : IsThreeCycle f) :
    f ∈ alternatingGroup α 
goal: f ∈ alternatingGroup α

full_name: Equiv.Perm.finRotate_bit1_mem_alternatingGroup
code: theorem finRotate_bit1_mem_alternatingGroup {n : ℕ} :
    finRotate (2 * n + 1) ∈ alternatingGroup (Fin (2 * n + 1)) 
goal: finRotate (2 * n + 1) ∈ alternatingGroup (Fin (2 * n + 1))

full_name: two_mul_card_alternatingGroup
code: theorem two_mul_card_alternatingGroup [Nontrivial α] :
    2 * card (alternatingGroup α) = card (Perm α) 
goal: 2 * Fintype.card ↥(alternatingGroup α) = Fintype.card (Equiv.Perm α)

full_name: alternatingGroup.normal
code: instance normal : (alternatingGroup α).Normal 
goal: (alternatingGroup α).Normal

full_name: alternatingGroup.isConj_of
code: theorem isConj_of {σ τ : alternatingGroup α} (hc : IsConj (σ : Perm α) (τ : Perm α))
    (hσ : (σ : Perm α).support.card + 2 ≤ Fintype.card α) : IsConj σ τ 
goal: IsConj σ τ

full_name: alternatingGroup.isThreeCycle_isConj
code: theorem isThreeCycle_isConj (h5 : 5 ≤ Fintype.card α) {σ τ : alternatingGroup α}
    (hσ : IsThreeCycle (σ : Perm α)) (hτ : IsThreeCycle (τ : Perm α)) : IsConj σ τ 
goal: IsConj σ τ

full_name: Equiv.Perm.closure_three_cycles_eq_alternating
code: @[simp]
theorem closure_three_cycles_eq_alternating :
    closure { σ : Perm α | IsThreeCycle σ } = alternatingGroup α 
goal: Subgroup.closure {σ | σ.IsThreeCycle} = alternatingGroup α

full_name: Equiv.Perm.IsThreeCycle.alternating_normalClosure
code: /-- A key lemma to prove $A_5$ is simple. Shows that any normal subgroup of an alternating group on
  at least 5 elements is the entire alternating group if it contains a 3-cycle. -/
theorem IsThreeCycle.alternating_normalClosure (h5 : 5 ≤ Fintype.card α) {f : Perm α}
    (hf : IsThreeCycle f) :
    normalClosure ({⟨f, hf.mem_alternatingGroup⟩} : Set (alternatingGroup α)) = ⊤ 
goal: Subgroup.normalClosure {⟨f, ⋯⟩} = ⊤

full_name: Equiv.Perm.isThreeCycle_sq_of_three_mem_cycleType_five
code: /-- Part of proving $A_5$ is simple. Shows that the square of any element of $A_5$ with a 3-cycle in
  its cycle decomposition is a 3-cycle, so the normal closure of the original element must be
  $A_5$. -/
theorem isThreeCycle_sq_of_three_mem_cycleType_five {g : Perm (Fin 5)} (h : 3 ∈ cycleType g) :
    IsThreeCycle (g * g) 
goal: (g * g).IsThreeCycle

full_name: alternatingGroup.nontrivial_of_three_le_card
code: theorem nontrivial_of_three_le_card (h3 : 3 ≤ card α) : Nontrivial (alternatingGroup α) 
goal: Nontrivial ↥(alternatingGroup α)

full_name: alternatingGroup.instNontrivialSubtypePermFinHAddNatOfNatMemSubgroup
code: instance {n : ℕ} : Nontrivial (alternatingGroup (Fin (n + 3))) 
goal: Nontrivial ↥(alternatingGroup (Fin (n + 3)))

full_name: alternatingGroup.normalClosure_finRotate_five
code: /-- The normal closure of the 5-cycle `finRotate 5` within $A_5$ is the whole group. This will be
  used to show that the normal closure of any 5-cycle within $A_5$ is the whole group. -/
theorem normalClosure_finRotate_five : normalClosure ({⟨finRotate 5,
    finRotate_bit1_mem_alternatingGroup (n := 2)⟩} : Set (alternatingGroup (Fin 5))) = ⊤ 
goal: Subgroup.normalClosure {⟨finRotate 5, ⋯⟩} = ⊤

full_name: alternatingGroup.normalClosure_swap_mul_swap_five
code: /-- The normal closure of $(04)(13)$ within $A_5$ is the whole group. This will be
  used to show that the normal closure of any permutation of cycle type $(2,2)$ is the whole group.
  -/
theorem normalClosure_swap_mul_swap_five :
    normalClosure
        ({⟨swap 0 4 * swap 1 3, mem_alternatingGroup.2 (by decide)⟩} :
          Set (alternatingGroup (Fin 5))) =
      ⊤ 
goal: Subgroup.normalClosure {⟨Equiv.swap 0 4 * Equiv.swap 1 3, ⋯⟩} = ⊤

full_name: alternatingGroup.isConj_swap_mul_swap_of_cycleType_two
code: /-- Shows that any non-identity element of $A_5$ whose cycle decomposition consists only of swaps
  is conjugate to $(04)(13)$. This is used to show that the normal closure of such a permutation
  in $A_5$ is $A_5$. -/
theorem isConj_swap_mul_swap_of_cycleType_two {g : Perm (Fin 5)} (ha : g ∈ alternatingGroup (Fin 5))
    (h1 : g ≠ 1) (h2 : ∀ n, n ∈ cycleType (g : Perm (Fin 5)) → n = 2) :
    IsConj (swap 0 4 * swap 1 3) g 
goal: IsConj (Equiv.swap 0 4 * Equiv.swap 1 3) g

full_name: alternatingGroup.isSimpleGroup_five
code: /-- Shows that $A_5$ is simple by taking an arbitrary non-identity element and showing by casework
  on its cycle type that its normal closure is all of $A_5$. -/
instance isSimpleGroup_five : IsSimpleGroup (alternatingGroup (Fin 5)) 
goal: IsSimpleGroup ↥(alternatingGroup (Fin 5))