url stringclasses 147
values | commit stringclasses 147
values | file_path stringlengths 7 101 | full_name stringlengths 1 94 | start stringlengths 6 10 | end stringlengths 6 11 | tactic stringlengths 1 11.2k | state_before stringlengths 3 2.09M | state_after stringlengths 6 2.09M | input stringlengths 73 2.09M |
|---|---|---|---|---|---|---|---|---|---|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.of_cycleType_eq | [3123, 1] | [3154, 19] | simp only [Finset.mem_filter, Finset.mem_univ, Subgroup.coe_mk, true_and_iff] at hk' | case pos.a.mp.intro.mk.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : Even (Multiset.sum m + Multiset.card m)
k : Equiv.Perm α
hk : k ∈ alternatingGroup α
hk' : { val := k, property := hk } ∈ Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ
⊢ Equiv.Perm.cycleType ({ toFun := ⇑(Subgroup.subtype (alternatingGroup α)), inj' := ⋯ } { val := k, property := hk }) =
m | case pos.a.mp.intro.mk.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : Even (Multiset.sum m + Multiset.card m)
k : Equiv.Perm α
hk : k ∈ alternatingGroup α
hk' : Equiv.Perm.cycleType k = m
⊢ Equiv.Perm.cycleType ({ toFun := ⇑(Subgroup.subtype (alternatingGroup α)), inj' := ⋯ } { val := k, property := hk }) =
m | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.a.mp.intro.mk.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : Even (Multiset.sum m + Multiset.card m)
k : Equiv.Perm α
hk : k ∈ alternatingGroup α
hk' : { val := k, property := hk } ∈ Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ
⊢ Equiv.Perm.cycleType ({ toFun := ⇑(Subgroup.subtype (alternatingGroup α)), inj' := ⋯ } { val := k, property := hk }) =
m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.of_cycleType_eq | [3123, 1] | [3154, 19] | simp only [Subgroup.coeSubtype, Function.Embedding.coeFn_mk, Subgroup.coe_mk] | case pos.a.mp.intro.mk.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : Even (Multiset.sum m + Multiset.card m)
k : Equiv.Perm α
hk : k ∈ alternatingGroup α
hk' : Equiv.Perm.cycleType k = m
⊢ Equiv.Perm.cycleType ({ toFun := ⇑(Subgroup.subtype (alternatingGroup α)), inj' := ⋯ } { val := k, property := hk }) =
m | case pos.a.mp.intro.mk.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : Even (Multiset.sum m + Multiset.card m)
k : Equiv.Perm α
hk : k ∈ alternatingGroup α
hk' : Equiv.Perm.cycleType k = m
⊢ Equiv.Perm.cycleType k = m | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.a.mp.intro.mk.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : Even (Multiset.sum m + Multiset.card m)
k : Equiv.Perm α
hk : k ∈ alternatingGroup α
hk' : Equiv.Perm.cycleType k = m
⊢ Equiv.Perm.cycleType ({ toFun := ⇑(Subgroup.subtype (alternatingGroup α)), inj' := ⋯ } { val := k, property := hk }) =
m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.of_cycleType_eq | [3123, 1] | [3154, 19] | exact hk' | case pos.a.mp.intro.mk.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : Even (Multiset.sum m + Multiset.card m)
k : Equiv.Perm α
hk : k ∈ alternatingGroup α
hk' : Equiv.Perm.cycleType k = m
⊢ Equiv.Perm.cycleType k = m | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.a.mp.intro.mk.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : Even (Multiset.sum m + Multiset.card m)
k : Equiv.Perm α
hk : k ∈ alternatingGroup α
hk' : Equiv.Perm.cycleType k = m
⊢ Equiv.Perm.cycleType k = m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.of_cycleType_eq | [3123, 1] | [3154, 19] | rintro ⟨_, hg⟩ | case pos.a.mpr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g✝ : Equiv.Perm α
m : Multiset ℕ
hm : Even (Multiset.sum m + Multiset.card m)
g : Equiv.Perm α
⊢ g ∈ Finset.univ ∧ Equiv.Perm.cycleType g = m →
g ∈
Finset.map { toFun := ⇑(Subgroup.subtype (alternatingGroup α)), inj' := ⋯ }
(Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ) | case pos.a.mpr.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g✝ : Equiv.Perm α
m : Multiset ℕ
hm : Even (Multiset.sum m + Multiset.card m)
g : Equiv.Perm α
left✝ : g ∈ Finset.univ
hg : Equiv.Perm.cycleType g = m
⊢ g ∈
Finset.map { toFun := ⇑(Subgroup.subtype (alternatingGroup α)), inj' := ⋯ }
(Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.a.mpr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g✝ : Equiv.Perm α
m : Multiset ℕ
hm : Even (Multiset.sum m + Multiset.card m)
g : Equiv.Perm α
⊢ g ∈ Finset.univ ∧ Equiv.Perm.cycleType g = m →
g ∈
Finset.map { toFun := ⇑(Subgroup.subtype (alternatingGroup α)), inj' := ⋯ }
(Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.of_cycleType_eq | [3123, 1] | [3154, 19] | simp only [Subgroup.coeSubtype, Finset.mem_map, Finset.mem_filter, Finset.mem_univ,
true_and_iff, Function.Embedding.coeFn_mk, exists_prop] | case pos.a.mpr.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g✝ : Equiv.Perm α
m : Multiset ℕ
hm : Even (Multiset.sum m + Multiset.card m)
g : Equiv.Perm α
left✝ : g ∈ Finset.univ
hg : Equiv.Perm.cycleType g = m
⊢ g ∈
Finset.map { toFun := ⇑(Subgroup.subtype (alternatingGroup α)), inj' := ⋯ }
(Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ) | case pos.a.mpr.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g✝ : Equiv.Perm α
m : Multiset ℕ
hm : Even (Multiset.sum m + Multiset.card m)
g : Equiv.Perm α
left✝ : g ∈ Finset.univ
hg : Equiv.Perm.cycleType g = m
⊢ ∃ a, Equiv.Perm.cycleType ↑a = m ∧ ↑a = g | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.a.mpr.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g✝ : Equiv.Perm α
m : Multiset ℕ
hm : Even (Multiset.sum m + Multiset.card m)
g : Equiv.Perm α
left✝ : g ∈ Finset.univ
hg : Equiv.Perm.cycleType g = m
⊢ g ∈
Finset.map { toFun := ⇑(Subgroup.subtype (alternatingGroup α)), inj' := ⋯ }
(Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.of_cycleType_eq | [3123, 1] | [3154, 19] | use! g | case pos.a.mpr.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g✝ : Equiv.Perm α
m : Multiset ℕ
hm : Even (Multiset.sum m + Multiset.card m)
g : Equiv.Perm α
left✝ : g ∈ Finset.univ
hg : Equiv.Perm.cycleType g = m
⊢ ∃ a, Equiv.Perm.cycleType ↑a = m ∧ ↑a = g | case property
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g✝ : Equiv.Perm α
m : Multiset ℕ
hm : Even (Multiset.sum m + Multiset.card m)
g : Equiv.Perm α
left✝ : g ∈ Finset.univ
hg : Equiv.Perm.cycleType g = m
⊢ g ∈ alternatingGroup α | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.a.mpr.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g✝ : Equiv.Perm α
m : Multiset ℕ
hm : Even (Multiset.sum m + Multiset.card m)
g : Equiv.Perm α
left✝ : g ∈ Finset.univ
hg : Equiv.Perm.cycleType g = m
⊢ ∃ a, Equiv.Perm.cycleType ↑a = m ∧ ↑a = g
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.of_cycleType_eq | [3123, 1] | [3154, 19] | rw [Equiv.Perm.mem_alternatingGroup, Equiv.Perm.sign_of_cycleType, hg, Even.neg_one_pow hm] | case property
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g✝ : Equiv.Perm α
m : Multiset ℕ
hm : Even (Multiset.sum m + Multiset.card m)
g : Equiv.Perm α
left✝ : g ∈ Finset.univ
hg : Equiv.Perm.cycleType g = m
⊢ g ∈ alternatingGroup α | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case property
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g✝ : Equiv.Perm α
m : Multiset ℕ
hm : Even (Multiset.sum m + Multiset.card m)
g : Equiv.Perm α
left✝ : g ∈ Finset.univ
hg : Equiv.Perm.cycleType g = m
⊢ g ∈ alternatingGroup α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.of_cycleType_eq | [3123, 1] | [3154, 19] | rw [Finset.eq_empty_iff_forall_not_mem] | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬Even (Multiset.sum m + Multiset.card m)
⊢ Finset.map { toFun := ⇑(Subgroup.subtype (alternatingGroup α)), inj' := ⋯ }
(Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ) =
∅ | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬Even (Multiset.sum m + Multiset.card m)
⊢ ∀ (x : Equiv.Perm α),
x ∉
Finset.map { toFun := ⇑(Subgroup.subtype (alternatingGroup α)), inj' := ⋯ }
(Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ) | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬Even (Multiset.sum m + Multiset.card m)
⊢ Finset.map { toFun := ⇑(Subgroup.subtype (alternatingGroup α)), inj' := ⋯ }
(Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ) =
∅
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.of_cycleType_eq | [3123, 1] | [3154, 19] | intro g hg | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬Even (Multiset.sum m + Multiset.card m)
⊢ ∀ (x : Equiv.Perm α),
x ∉
Finset.map { toFun := ⇑(Subgroup.subtype (alternatingGroup α)), inj' := ⋯ }
(Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ) | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g✝ : Equiv.Perm α
m : Multiset ℕ
hm : ¬Even (Multiset.sum m + Multiset.card m)
g : Equiv.Perm α
hg :
g ∈
Finset.map { toFun := ⇑(Subgroup.subtype (alternatingGroup α)), inj' := ⋯ }
(Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ)
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬Even (Multiset.sum m + Multiset.card m)
⊢ ∀ (x : Equiv.Perm α),
x ∉
Finset.map { toFun := ⇑(Subgroup.subtype (alternatingGroup α)), inj' := ⋯ }
(Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.of_cycleType_eq | [3123, 1] | [3154, 19] | simp only [Subgroup.coeSubtype, Finset.mem_map, Finset.mem_filter, Finset.mem_univ,
true_and_iff, Function.Embedding.coeFn_mk, exists_prop] at hg | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g✝ : Equiv.Perm α
m : Multiset ℕ
hm : ¬Even (Multiset.sum m + Multiset.card m)
g : Equiv.Perm α
hg :
g ∈
Finset.map { toFun := ⇑(Subgroup.subtype (alternatingGroup α)), inj' := ⋯ }
(Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ)
⊢ False | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g✝ : Equiv.Perm α
m : Multiset ℕ
hm : ¬Even (Multiset.sum m + Multiset.card m)
g : Equiv.Perm α
hg : ∃ a, Equiv.Perm.cycleType ↑a = m ∧ ↑a = g
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g✝ : Equiv.Perm α
m : Multiset ℕ
hm : ¬Even (Multiset.sum m + Multiset.card m)
g : Equiv.Perm α
hg :
g ∈
Finset.map { toFun := ⇑(Subgroup.subtype (alternatingGroup α)), inj' := ⋯ }
(Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ)
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.of_cycleType_eq | [3123, 1] | [3154, 19] | obtain ⟨⟨k, hk⟩, hkm, rfl⟩ := hg | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g✝ : Equiv.Perm α
m : Multiset ℕ
hm : ¬Even (Multiset.sum m + Multiset.card m)
g : Equiv.Perm α
hg : ∃ a, Equiv.Perm.cycleType ↑a = m ∧ ↑a = g
⊢ False | case neg.intro.mk.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬Even (Multiset.sum m + Multiset.card m)
k : Equiv.Perm α
hk : k ∈ alternatingGroup α
hkm : Equiv.Perm.cycleType ↑{ val := k, property := hk } = m
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g✝ : Equiv.Perm α
m : Multiset ℕ
hm : ¬Even (Multiset.sum m + Multiset.card m)
g : Equiv.Perm α
hg : ∃ a, Equiv.Perm.cycleType ↑a = m ∧ ↑a = g
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.of_cycleType_eq | [3123, 1] | [3154, 19] | rw [← Nat.odd_iff_not_even] at hm | case neg.intro.mk.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬Even (Multiset.sum m + Multiset.card m)
k : Equiv.Perm α
hk : k ∈ alternatingGroup α
hkm : Equiv.Perm.cycleType ↑{ val := k, property := hk } = m
⊢ False | case neg.intro.mk.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : Odd (Multiset.sum m + Multiset.card m)
k : Equiv.Perm α
hk : k ∈ alternatingGroup α
hkm : Equiv.Perm.cycleType ↑{ val := k, property := hk } = m
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.intro.mk.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬Even (Multiset.sum m + Multiset.card m)
k : Equiv.Perm α
hk : k ∈ alternatingGroup α
hkm : Equiv.Perm.cycleType ↑{ val := k, property := hk } = m
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.of_cycleType_eq | [3123, 1] | [3154, 19] | simp only [Subgroup.coe_mk] at hkm | case neg.intro.mk.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : Odd (Multiset.sum m + Multiset.card m)
k : Equiv.Perm α
hk : k ∈ alternatingGroup α
hkm : Equiv.Perm.cycleType ↑{ val := k, property := hk } = m
⊢ False | case neg.intro.mk.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : Odd (Multiset.sum m + Multiset.card m)
k : Equiv.Perm α
hk : k ∈ alternatingGroup α
hkm : Equiv.Perm.cycleType k = m
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.intro.mk.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : Odd (Multiset.sum m + Multiset.card m)
k : Equiv.Perm α
hk : k ∈ alternatingGroup α
hkm : Equiv.Perm.cycleType ↑{ val := k, property := hk } = m
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.of_cycleType_eq | [3123, 1] | [3154, 19] | simp only [Equiv.Perm.mem_alternatingGroup, Equiv.Perm.sign_of_cycleType, hkm, Odd.neg_one_pow hm, ← Units.eq_iff] at hk | case neg.intro.mk.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : Odd (Multiset.sum m + Multiset.card m)
k : Equiv.Perm α
hk : k ∈ alternatingGroup α
hkm : Equiv.Perm.cycleType k = m
⊢ False | case neg.intro.mk.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : Odd (Multiset.sum m + Multiset.card m)
k : Equiv.Perm α
hkm : Equiv.Perm.cycleType k = m
hk : ↑(-1) = ↑1
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.intro.mk.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : Odd (Multiset.sum m + Multiset.card m)
k : Equiv.Perm α
hk : k ∈ alternatingGroup α
hkm : Equiv.Perm.cycleType k = m
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.of_cycleType_eq | [3123, 1] | [3154, 19] | norm_num at hk | case neg.intro.mk.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : Odd (Multiset.sum m + Multiset.card m)
k : Equiv.Perm α
hkm : Equiv.Perm.cycleType k = m
hk : ↑(-1) = ↑1
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.intro.mk.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : Odd (Multiset.sum m + Multiset.card m)
k : Equiv.Perm α
hkm : Equiv.Perm.cycleType k = m
hk : ↑(-1) = ↑1
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | split_ifs with hm | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
if (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m) then
Nat.factorial (Fintype.card α)
else 0 | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
Nat.factorial (Fintype.card α)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
if (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m) then
Nat.factorial (Fintype.card α)
else 0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | rw [← Finset.card_map] | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
Nat.factorial (Fintype.card α) | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (Finset.map ?pos✝ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ)).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
Nat.factorial (Fintype.card α)
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ ↥(alternatingGroup α) ↪ ?m.477188
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Type ?u.477186 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
Nat.factorial (Fintype.card α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | rw [AlternatingGroup.of_cycleType_eq] | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (Finset.map ?pos✝ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ)).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
Nat.factorial (Fintype.card α)
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ ↥(alternatingGroup α) ↪ ?m.477188
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Type ?u.477186 | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ
else ∅).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
Nat.factorial (Fintype.card α) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (Finset.map ?pos✝ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ)).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
Nat.factorial (Fintype.card α)
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ ↥(alternatingGroup α) ↪ ?m.477188
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Type ?u.477186
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | rw [if_pos] | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ
else ∅).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
Nat.factorial (Fintype.card α) | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
Nat.factorial (Fintype.card α)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ
else ∅).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
Nat.factorial (Fintype.card α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | have := Equiv.Perm.card_of_cycleType_mul_eq α m | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
Nat.factorial (Fintype.card α)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m) | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
this :
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) * Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m))) =
if Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a then Nat.factorial (Fintype.card α) else 0
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
Nat.factorial (Fintype.card α)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
Nat.factorial (Fintype.card α)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | simp only [mul_assoc] at this | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
this :
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) * Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m))) =
if Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a then Nat.factorial (Fintype.card α) else 0
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
Nat.factorial (Fintype.card α)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m) | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
this :
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
if Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a then Nat.factorial (Fintype.card α) else 0
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
Nat.factorial (Fintype.card α)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
this :
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) * Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m))) =
if Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a then Nat.factorial (Fintype.card α) else 0
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
Nat.factorial (Fintype.card α)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | rw [this] | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
this :
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
if Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a then Nat.factorial (Fintype.card α) else 0
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
Nat.factorial (Fintype.card α)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m) | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
this :
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
if Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a then Nat.factorial (Fintype.card α) else 0
⊢ (if Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a then Nat.factorial (Fintype.card α) else 0) =
Nat.factorial (Fintype.card α)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
this :
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
if Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a then Nat.factorial (Fintype.card α) else 0
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
Nat.factorial (Fintype.card α)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | rw [if_pos] | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
this :
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
if Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a then Nat.factorial (Fintype.card α) else 0
⊢ (if Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a then Nat.factorial (Fintype.card α) else 0) =
Nat.factorial (Fintype.card α)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m) | case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
this :
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
if Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a then Nat.factorial (Fintype.card α) else 0
⊢ Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
this :
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
if Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a then Nat.factorial (Fintype.card α) else 0
⊢ (if Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a then Nat.factorial (Fintype.card α) else 0) =
Nat.factorial (Fintype.card α)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | exact hm.1 | case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
this :
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
if Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a then Nat.factorial (Fintype.card α) else 0
⊢ Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m) | case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
this :
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
if Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a then Nat.factorial (Fintype.card α) else 0
⊢ Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | exact hm.2 | case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | rw [← Finset.card_map] | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (Finset.map ?neg✝ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ)).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ ↥(alternatingGroup α) ↪ ?m.477900
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ Type ?u.477898 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | rw [AlternatingGroup.of_cycleType_eq] | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (Finset.map ?neg✝ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ)).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ ↥(alternatingGroup α) ↪ ?m.477900
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ Type ?u.477898 | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (if Even (Multiset.sum m + Multiset.card m) then Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ
else ∅).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (Finset.map ?neg✝ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ)).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ ↥(alternatingGroup α) ↪ ?m.477900
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ Type ?u.477898
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | rw [apply_ite Finset.card] | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (if Even (Multiset.sum m + Multiset.card m) then Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ
else ∅).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else ∅.card) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (if Even (Multiset.sum m + Multiset.card m) then Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ
else ∅).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | rw [Finset.card_empty] | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else ∅.card) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else ∅.card) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | rw [not_and_or] at hm | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | by_cases hm' : Even (m.sum + Multiset.card m) | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | rw [if_pos] | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | rw [Equiv.Perm.card_of_cycleType] | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ (if Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a then
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) * Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | rw [if_neg] | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ (if Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a then
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) * Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ 0 *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
case pos.hnc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ (if Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a then
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) * Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | exact MulZeroClass.zero_mul _ | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ 0 *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
case pos.hnc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | case pos.hnc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ 0 *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
case pos.hnc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | cases' hm with hm hm | case pos.hnc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | case pos.hnc.inl
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm' : Even (Multiset.sum m + Multiset.card m)
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hnc.inr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm' : Even (Multiset.sum m + Multiset.card m)
hm : ¬Even (Multiset.sum m + Multiset.card m)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.hnc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | exact hm | case pos.hnc.inl
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm' : Even (Multiset.sum m + Multiset.card m)
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hnc.inr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm' : Even (Multiset.sum m + Multiset.card m)
hm : ¬Even (Multiset.sum m + Multiset.card m)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | case pos.hnc.inr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm' : Even (Multiset.sum m + Multiset.card m)
hm : ¬Even (Multiset.sum m + Multiset.card m)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.hnc.inl
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm' : Even (Multiset.sum m + Multiset.card m)
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hnc.inr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm' : Even (Multiset.sum m + Multiset.card m)
hm : ¬Even (Multiset.sum m + Multiset.card m)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | exfalso | case pos.hnc.inr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm' : Even (Multiset.sum m + Multiset.card m)
hm : ¬Even (Multiset.sum m + Multiset.card m)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | case pos.hnc.inr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm' : Even (Multiset.sum m + Multiset.card m)
hm : ¬Even (Multiset.sum m + Multiset.card m)
⊢ False
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.hnc.inr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm' : Even (Multiset.sum m + Multiset.card m)
hm : ¬Even (Multiset.sum m + Multiset.card m)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | exact hm hm' | case pos.hnc.inr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm' : Even (Multiset.sum m + Multiset.card m)
hm : ¬Even (Multiset.sum m + Multiset.card m)
⊢ False
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.hnc.inr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm' : Even (Multiset.sum m + Multiset.card m)
hm : ¬Even (Multiset.sum m + Multiset.card m)
⊢ False
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | exact hm' | case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | rw [if_neg] | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0 | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ 0 *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
case neg.hnc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ ¬Even (Multiset.sum m + Multiset.card m) | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | exact MulZeroClass.zero_mul _ | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ 0 *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
case neg.hnc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ ¬Even (Multiset.sum m + Multiset.card m) | case neg.hnc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ ¬Even (Multiset.sum m + Multiset.card m) | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ 0 *
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) =
0
case neg.hnc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ ¬Even (Multiset.sum m + Multiset.card m)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType_mul_eq | [3157, 1] | [3189, 58] | exact hm' | case neg.hnc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ ¬Even (Multiset.sum m + Multiset.card m) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.hnc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ ¬Even (Multiset.sum m + Multiset.card m)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType | [3192, 1] | [3221, 27] | split_ifs with hm | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ).card =
if (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m) then
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m))))
else 0 | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ).card =
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m))))
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ).card = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ).card =
if (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m) then
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m))))
else 0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType | [3192, 1] | [3221, 27] | rw [← Finset.card_map] | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ).card =
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (Finset.map ?pos✝ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ)).card =
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m))))
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ ↥(alternatingGroup α) ↪ ?m.482132
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Type ?u.482130 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ).card =
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m))))
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType | [3192, 1] | [3221, 27] | rw [AlternatingGroup.of_cycleType_eq] | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (Finset.map ?pos✝ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ)).card =
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m))))
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ ↥(alternatingGroup α) ↪ ?m.482132
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Type ?u.482130 | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ
else ∅).card =
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (Finset.map ?pos✝ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ)).card =
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m))))
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ ↥(alternatingGroup α) ↪ ?m.482132
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Type ?u.482130
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType | [3192, 1] | [3221, 27] | rw [if_pos] | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ
else ∅).card =
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))) | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card =
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m))))
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ
else ∅).card =
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m))))
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType | [3192, 1] | [3221, 27] | rw [Equiv.Perm.card_of_cycleType α m] | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card =
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m))))
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m) | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (if Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a then
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) * Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))
else 0) =
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m))))
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card =
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m))))
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType | [3192, 1] | [3221, 27] | rw [if_pos] | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (if Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a then
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) * Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))
else 0) =
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m))))
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m) | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) * Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m))) =
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m))))
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ (if Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a then
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) * Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))
else 0) =
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m))))
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType | [3192, 1] | [3221, 27] | simp only [mul_assoc] | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) * Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m))) =
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m))))
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m) | case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) * Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m))) =
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) *
(Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m))))
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType | [3192, 1] | [3221, 27] | exact hm.1 | case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m) | case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType | [3192, 1] | [3221, 27] | exact hm.2 | case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType | [3192, 1] | [3221, 27] | rw [← Finset.card_map] | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ).card = 0 | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (Finset.map ?neg✝ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ)).card = 0
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ ↥(alternatingGroup α) ↪ ?m.482556
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ Type ?u.482554 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ).card = 0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType | [3192, 1] | [3221, 27] | rw [AlternatingGroup.of_cycleType_eq] | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (Finset.map ?neg✝ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ)).card = 0
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ ↥(alternatingGroup α) ↪ ?m.482556
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ Type ?u.482554 | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (if Even (Multiset.sum m + Multiset.card m) then Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ
else ∅).card =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (Finset.map ?neg✝ (Finset.filter (fun g => Equiv.Perm.cycleType ↑g = m) Finset.univ)).card = 0
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ ↥(alternatingGroup α) ↪ ?m.482556
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ Type ?u.482554
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType | [3192, 1] | [3221, 27] | rw [apply_ite Finset.card] | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (if Even (Multiset.sum m + Multiset.card m) then Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ
else ∅).card =
0 | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else ∅.card) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (if Even (Multiset.sum m + Multiset.card m) then Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ
else ∅).card =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType | [3192, 1] | [3221, 27] | rw [Finset.card_empty] | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else ∅.card) =
0 | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else ∅.card) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType | [3192, 1] | [3221, 27] | rw [not_and_or] at hm | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0 | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬((Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∧ Even (Multiset.sum m + Multiset.card m))
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType | [3192, 1] | [3221, 27] | by_cases hm' : Even (m.sum + Multiset.card m) | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0 | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType | [3192, 1] | [3221, 27] | rw [if_pos] | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0 | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card = 0
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType | [3192, 1] | [3221, 27] | rw [Equiv.Perm.card_of_cycleType] | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card = 0
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0 | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ (if Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a then
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) * Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))
else 0) =
0
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ (Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card = 0
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType | [3192, 1] | [3221, 27] | rw [if_neg] | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ (if Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a then
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) * Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))
else 0) =
0
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0 | case pos.hnc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ (if Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a then
Nat.factorial (Fintype.card α) /
(Nat.factorial (Fintype.card α - Multiset.sum m) * Multiset.prod m *
Multiset.prod (Multiset.map (fun n => Nat.factorial (Multiset.count n m)) (Multiset.dedup m)))
else 0) =
0
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType | [3192, 1] | [3221, 27] | cases' hm with hm hm | case pos.hnc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0 | case pos.hnc.inl
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm' : Even (Multiset.sum m + Multiset.card m)
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hnc.inr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm' : Even (Multiset.sum m + Multiset.card m)
hm : ¬Even (Multiset.sum m + Multiset.card m)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.hnc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType | [3192, 1] | [3221, 27] | exact hm | case pos.hnc.inl
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm' : Even (Multiset.sum m + Multiset.card m)
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hnc.inr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm' : Even (Multiset.sum m + Multiset.card m)
hm : ¬Even (Multiset.sum m + Multiset.card m)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0 | case pos.hnc.inr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm' : Even (Multiset.sum m + Multiset.card m)
hm : ¬Even (Multiset.sum m + Multiset.card m)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.hnc.inl
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm' : Even (Multiset.sum m + Multiset.card m)
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hnc.inr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm' : Even (Multiset.sum m + Multiset.card m)
hm : ¬Even (Multiset.sum m + Multiset.card m)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType | [3192, 1] | [3221, 27] | exfalso | case pos.hnc.inr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm' : Even (Multiset.sum m + Multiset.card m)
hm : ¬Even (Multiset.sum m + Multiset.card m)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0 | case pos.hnc.inr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm' : Even (Multiset.sum m + Multiset.card m)
hm : ¬Even (Multiset.sum m + Multiset.card m)
⊢ False
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.hnc.inr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm' : Even (Multiset.sum m + Multiset.card m)
hm : ¬Even (Multiset.sum m + Multiset.card m)
⊢ ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a)
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType | [3192, 1] | [3221, 27] | exact hm hm' | case pos.hnc.inr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm' : Even (Multiset.sum m + Multiset.card m)
hm : ¬Even (Multiset.sum m + Multiset.card m)
⊢ False
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0 | case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.hnc.inr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm' : Even (Multiset.sum m + Multiset.card m)
hm : ¬Even (Multiset.sum m + Multiset.card m)
⊢ False
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType | [3192, 1] | [3221, 27] | exact hm' | case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0 | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : Even (Multiset.sum m + Multiset.card m)
⊢ Even (Multiset.sum m + Multiset.card m)
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType | [3192, 1] | [3221, 27] | rw [if_neg] | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0 | case neg.hnc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ ¬Even (Multiset.sum m + Multiset.card m) | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ (if Even (Multiset.sum m + Multiset.card m) then
(Finset.filter (fun g => Equiv.Perm.cycleType g = m) Finset.univ).card
else 0) =
0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.AlternatingGroup.card_of_cycleType | [3192, 1] | [3221, 27] | exact hm' | case neg.hnc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ ¬Even (Multiset.sum m + Multiset.card m) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.hnc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
m : Multiset ℕ
hm : ¬(Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) ∨ ¬Even (Multiset.sum m + Multiset.card m)
hm' : ¬Even (Multiset.sum m + Multiset.card m)
⊢ ¬Even (Multiset.sum m + Multiset.card m)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_fst | [3226, 1] | [3238, 8] | ext x | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
⊢ (θ g) (k, 1) = Equiv.Perm.ofSubtype k | case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
⊢ ((θ g) (k, 1)) x = (Equiv.Perm.ofSubtype k) x | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
⊢ (θ g) (k, 1) = Equiv.Perm.ofSubtype k
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_fst | [3226, 1] | [3238, 8] | by_cases hx : g.cycleOf x ∈ g.cycleFactorsFinset | case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
⊢ ((θ g) (k, 1)) x = (Equiv.Perm.ofSubtype k) x | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
⊢ ((θ g) (k, 1)) x = (Equiv.Perm.ofSubtype k) x
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : Equiv.Perm.cycleOf g x ∉ Equiv.Perm.cycleFactorsFinset g
⊢ ((θ g) (k, 1)) x = (Equiv.Perm.ofSubtype k) x | Please generate a tactic in lean4 to solve the state.
STATE:
case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
⊢ ((θ g) (k, 1)) x = (Equiv.Perm.ofSubtype k) x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_fst | [3226, 1] | [3238, 8] | rw [hθ_2 _ x ⟨g.cycleOf x, hx⟩ rfl] | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
⊢ ((θ g) (k, 1)) x = (Equiv.Perm.ofSubtype k) x | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
⊢ ↑((k, 1).2 { val := Equiv.Perm.cycleOf g x, property := hx }) x = (Equiv.Perm.ofSubtype k) x | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
⊢ ((θ g) (k, 1)) x = (Equiv.Perm.ofSubtype k) x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_fst | [3226, 1] | [3238, 8] | simp only [Pi.one_apply, OneMemClass.coe_one, Equiv.Perm.coe_one, id_eq] | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
⊢ ↑((k, 1).2 { val := Equiv.Perm.cycleOf g x, property := hx }) x = (Equiv.Perm.ofSubtype k) x | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
⊢ x = (Equiv.Perm.ofSubtype k) x | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
⊢ ↑((k, 1).2 { val := Equiv.Perm.cycleOf g x, property := hx }) x = (Equiv.Perm.ofSubtype k) x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_fst | [3226, 1] | [3238, 8] | rw [Equiv.Perm.ofSubtype_apply_of_not_mem] | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
⊢ x = (Equiv.Perm.ofSubtype k) x | case pos.ha
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
⊢ x ∉ MulAction.fixedBy α g | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
⊢ x = (Equiv.Perm.ofSubtype k) x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_fst | [3226, 1] | [3238, 8] | simp only [MulAction.mem_fixedBy, Equiv.Perm.smul_def, ← Equiv.Perm.mem_support, ← Equiv.Perm.cycleOf_mem_cycleFactorsFinset_iff] | case pos.ha
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
⊢ x ∉ MulAction.fixedBy α g | case pos.ha
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
⊢ Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.ha
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
⊢ x ∉ MulAction.fixedBy α g
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_fst | [3226, 1] | [3238, 8] | exact hx | case pos.ha
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
⊢ Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.ha
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
⊢ Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_fst | [3226, 1] | [3238, 8] | rw [Equiv.Perm.cycleOf_mem_cycleFactorsFinset_iff, Equiv.Perm.not_mem_support] at hx | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : Equiv.Perm.cycleOf g x ∉ Equiv.Perm.cycleFactorsFinset g
⊢ ((θ g) (k, 1)) x = (Equiv.Perm.ofSubtype k) x | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : g x = x
⊢ ((θ g) (k, 1)) x = (Equiv.Perm.ofSubtype k) x | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : Equiv.Perm.cycleOf g x ∉ Equiv.Perm.cycleFactorsFinset g
⊢ ((θ g) (k, 1)) x = (Equiv.Perm.ofSubtype k) x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_fst | [3226, 1] | [3238, 8] | rw [hθ_1 _ x hx, Equiv.Perm.ofSubtype_apply_of_mem] | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : g x = x
⊢ ((θ g) (k, 1)) x = (Equiv.Perm.ofSubtype k) x | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : g x = x
⊢ ↑((k, 1).1 { val := x, property := hx }) = ↑(k { val := x, property := ?neg.ha✝ })
case neg.ha
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : g x = x
⊢ x ∈ MulAction.fixedBy α g | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : g x = x
⊢ ((θ g) (k, 1)) x = (Equiv.Perm.ofSubtype k) x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_fst | [3226, 1] | [3238, 8] | rfl | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : g x = x
⊢ ↑((k, 1).1 { val := x, property := hx }) = ↑(k { val := x, property := ?neg.ha✝ })
case neg.ha
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : g x = x
⊢ x ∈ MulAction.fixedBy α g | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : g x = x
⊢ ↑((k, 1).1 { val := x, property := hx }) = ↑(k { val := x, property := ?neg.ha✝ })
case neg.ha
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
k : Equiv.Perm ↑(MulAction.fixedBy α g)
x : α
hx : g x = x
⊢ x ∈ MulAction.fixedBy α g
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_single | [3240, 1] | [3279, 45] | ext x | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
⊢ (θ g) (1, Pi.mulSingle c vc) = ↑vc | case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
⊢ ((θ g) (1, Pi.mulSingle c vc)) x = ↑vc x | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
⊢ (θ g) (1, Pi.mulSingle c vc) = ↑vc
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_single | [3240, 1] | [3279, 45] | by_cases hx : g.cycleOf x ∈ g.cycleFactorsFinset | case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
⊢ ((θ g) (1, Pi.mulSingle c vc)) x = ↑vc x | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
⊢ ((θ g) (1, Pi.mulSingle c vc)) x = ↑vc x
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∉ Equiv.Perm.cycleFactorsFinset g
⊢ ((θ g) (1, Pi.mulSingle c vc)) x = ↑vc x | Please generate a tactic in lean4 to solve the state.
STATE:
case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
⊢ ((θ g) (1, Pi.mulSingle c vc)) x = ↑vc x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_single | [3240, 1] | [3279, 45] | rw [hθ_2 _ x ⟨g.cycleOf x, hx⟩ rfl] | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
⊢ ((θ g) (1, Pi.mulSingle c vc)) x = ↑vc x | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
⊢ ↑((1, Pi.mulSingle c vc).2 { val := Equiv.Perm.cycleOf g x, property := hx }) x = ↑vc x | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
⊢ ((θ g) (1, Pi.mulSingle c vc)) x = ↑vc x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_single | [3240, 1] | [3279, 45] | by_cases hc : g.cycleOf x = c | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
⊢ ↑((1, Pi.mulSingle c vc).2 { val := Equiv.Perm.cycleOf g x, property := hx }) x = ↑vc x | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : Equiv.Perm.cycleOf g x = ↑c
⊢ ↑((1, Pi.mulSingle c vc).2 { val := Equiv.Perm.cycleOf g x, property := hx }) x = ↑vc x
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ ↑((1, Pi.mulSingle c vc).2 { val := Equiv.Perm.cycleOf g x, property := hx }) x = ↑vc x | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
⊢ ↑((1, Pi.mulSingle c vc).2 { val := Equiv.Perm.cycleOf g x, property := hx }) x = ↑vc x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_single | [3240, 1] | [3279, 45] | suffices c = ⟨g.cycleOf x, hx⟩ by
rw [← this]
simp only [Pi.mulSingle_eq_same] | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : Equiv.Perm.cycleOf g x = ↑c
⊢ ↑((1, Pi.mulSingle c vc).2 { val := Equiv.Perm.cycleOf g x, property := hx }) x = ↑vc x | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : Equiv.Perm.cycleOf g x = ↑c
⊢ c = { val := Equiv.Perm.cycleOf g x, property := hx } | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : Equiv.Perm.cycleOf g x = ↑c
⊢ ↑((1, Pi.mulSingle c vc).2 { val := Equiv.Perm.cycleOf g x, property := hx }) x = ↑vc x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_single | [3240, 1] | [3279, 45] | rw [← Subtype.coe_inj, ← hc] | case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : Equiv.Perm.cycleOf g x = ↑c
⊢ c = { val := Equiv.Perm.cycleOf g x, property := hx } | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : Equiv.Perm.cycleOf g x = ↑c
⊢ c = { val := Equiv.Perm.cycleOf g x, property := hx }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_single | [3240, 1] | [3279, 45] | rw [← this] | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : Equiv.Perm.cycleOf g x = ↑c
this : c = { val := Equiv.Perm.cycleOf g x, property := hx }
⊢ ↑((1, Pi.mulSingle c vc).2 { val := Equiv.Perm.cycleOf g x, property := hx }) x = ↑vc x | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : Equiv.Perm.cycleOf g x = ↑c
this : c = { val := Equiv.Perm.cycleOf g x, property := hx }
⊢ ↑((1, Pi.mulSingle c vc).2 c) x = ↑vc x | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : Equiv.Perm.cycleOf g x = ↑c
this : c = { val := Equiv.Perm.cycleOf g x, property := hx }
⊢ ↑((1, Pi.mulSingle c vc).2 { val := Equiv.Perm.cycleOf g x, property := hx }) x = ↑vc x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_single | [3240, 1] | [3279, 45] | simp only [Pi.mulSingle_eq_same] | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : Equiv.Perm.cycleOf g x = ↑c
this : c = { val := Equiv.Perm.cycleOf g x, property := hx }
⊢ ↑((1, Pi.mulSingle c vc).2 c) x = ↑vc x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : Equiv.Perm.cycleOf g x = ↑c
this : c = { val := Equiv.Perm.cycleOf g x, property := hx }
⊢ ↑((1, Pi.mulSingle c vc).2 c) x = ↑vc x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_single | [3240, 1] | [3279, 45] | simp only [ne_eq] | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ ↑((1, Pi.mulSingle c vc).2 { val := Equiv.Perm.cycleOf g x, property := hx }) x = ↑vc x | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ ↑(Pi.mulSingle c vc { val := Equiv.Perm.cycleOf g x, property := hx }) x = ↑vc x | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ ↑((1, Pi.mulSingle c vc).2 { val := Equiv.Perm.cycleOf g x, property := hx }) x = ↑vc x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_single | [3240, 1] | [3279, 45] | rw [Pi.mulSingle_eq_of_ne] | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ ↑(Pi.mulSingle c vc { val := Equiv.Perm.cycleOf g x, property := hx }) x = ↑vc x | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ ↑1 x = ↑vc x
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ ↑(Pi.mulSingle c vc { val := Equiv.Perm.cycleOf g x, property := hx }) x = ↑vc x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_single | [3240, 1] | [3279, 45] | simp only [OneMemClass.coe_one, Equiv.Perm.coe_one, id_eq] | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ ↑1 x = ↑vc x
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ x = ↑vc x
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ ↑1 x = ↑vc x
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_single | [3240, 1] | [3279, 45] | apply symm | case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ x = ↑vc x
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c | case neg.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ ↑vc x = x
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ x = ↑vc x
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_single | [3240, 1] | [3279, 45] | obtain ⟨m, hm⟩ := vc.prop | case neg.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ ↑vc x = x
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c | case neg.a.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : (fun x => ↑c ^ x) m = ↑vc
⊢ ↑vc x = x
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ ↑vc x = x
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_single | [3240, 1] | [3279, 45] | dsimp at hm | case neg.a.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : (fun x => ↑c ^ x) m = ↑vc
⊢ ↑vc x = x
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c | case neg.a.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : ↑c ^ m = ↑vc
⊢ ↑vc x = x
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.a.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : (fun x => ↑c ^ x) m = ↑vc
⊢ ↑vc x = x
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_single | [3240, 1] | [3279, 45] | rw [← hm, ← Equiv.Perm.not_mem_support] | case neg.a.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : ↑c ^ m = ↑vc
⊢ ↑vc x = x
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c | case neg.a.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : ↑c ^ m = ↑vc
⊢ x ∉ Equiv.Perm.support (↑c ^ m)
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.a.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : ↑c ^ m = ↑vc
⊢ ↑vc x = x
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_single | [3240, 1] | [3279, 45] | intro hx' | case neg.a.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : ↑c ^ m = ↑vc
⊢ x ∉ Equiv.Perm.support (↑c ^ m)
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c | case neg.a.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : ↑c ^ m = ↑vc
hx' : x ∈ Equiv.Perm.support (↑c ^ m)
⊢ False
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.a.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : ↑c ^ m = ↑vc
⊢ x ∉ Equiv.Perm.support (↑c ^ m)
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_single | [3240, 1] | [3279, 45] | apply hc | case neg.a.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : ↑c ^ m = ↑vc
hx' : x ∈ Equiv.Perm.support (↑c ^ m)
⊢ False
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c | case neg.a.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : ↑c ^ m = ↑vc
hx' : x ∈ Equiv.Perm.support (↑c ^ m)
⊢ Equiv.Perm.cycleOf g x = ↑c
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.a.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : ↑c ^ m = ↑vc
hx' : x ∈ Equiv.Perm.support (↑c ^ m)
⊢ False
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_single | [3240, 1] | [3279, 45] | apply symm | case neg.a.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : ↑c ^ m = ↑vc
hx' : x ∈ Equiv.Perm.support (↑c ^ m)
⊢ Equiv.Perm.cycleOf g x = ↑c
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c | case neg.a.intro.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : ↑c ^ m = ↑vc
hx' : x ∈ Equiv.Perm.support (↑c ^ m)
⊢ ↑c = Equiv.Perm.cycleOf g x
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.a.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : ↑c ^ m = ↑vc
hx' : x ∈ Equiv.Perm.support (↑c ^ m)
⊢ Equiv.Perm.cycleOf g x = ↑c
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_single | [3240, 1] | [3279, 45] | apply Equiv.Perm.cycle_is_cycleOf | case neg.a.intro.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : ↑c ^ m = ↑vc
hx' : x ∈ Equiv.Perm.support (↑c ^ m)
⊢ ↑c = Equiv.Perm.cycleOf g x
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c | case neg.a.intro.a.ha
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : ↑c ^ m = ↑vc
hx' : x ∈ Equiv.Perm.support (↑c ^ m)
⊢ x ∈ Equiv.Perm.support ↑c
case neg.a.intro.a.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : ↑c ^ m = ↑vc
hx' : x ∈ Equiv.Perm.support (↑c ^ m)
⊢ ↑c ∈ Equiv.Perm.cycleFactorsFinset g
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.a.intro.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : ↑c ^ m = ↑vc
hx' : x ∈ Equiv.Perm.support (↑c ^ m)
⊢ ↑c = Equiv.Perm.cycleOf g x
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_single | [3240, 1] | [3279, 45] | apply Equiv.Perm.support_zpow_le _ _ hx' | case neg.a.intro.a.ha
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : ↑c ^ m = ↑vc
hx' : x ∈ Equiv.Perm.support (↑c ^ m)
⊢ x ∈ Equiv.Perm.support ↑c
case neg.a.intro.a.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : ↑c ^ m = ↑vc
hx' : x ∈ Equiv.Perm.support (↑c ^ m)
⊢ ↑c ∈ Equiv.Perm.cycleFactorsFinset g
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c | case neg.a.intro.a.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : ↑c ^ m = ↑vc
hx' : x ∈ Equiv.Perm.support (↑c ^ m)
⊢ ↑c ∈ Equiv.Perm.cycleFactorsFinset g
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.a.intro.a.ha
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : ↑c ^ m = ↑vc
hx' : x ∈ Equiv.Perm.support (↑c ^ m)
⊢ x ∈ Equiv.Perm.support ↑c
case neg.a.intro.a.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : ↑c ^ m = ↑vc
hx' : x ∈ Equiv.Perm.support (↑c ^ m)
⊢ ↑c ∈ Equiv.Perm.cycleFactorsFinset g
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_single | [3240, 1] | [3279, 45] | exact c.prop | case neg.a.intro.a.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : ↑c ^ m = ↑vc
hx' : x ∈ Equiv.Perm.support (↑c ^ m)
⊢ ↑c ∈ Equiv.Perm.cycleFactorsFinset g
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c | case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.a.intro.a.hc
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
m : ℤ
hm : ↑c ^ m = ↑vc
hx' : x ∈ Equiv.Perm.support (↑c ^ m)
⊢ ↑c ∈ Equiv.Perm.cycleFactorsFinset g
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | OnCycleFactors.θ_apply_single | [3240, 1] | [3279, 45] | intro hc' | case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c | case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
hc' : { val := Equiv.Perm.cycleOf g x, property := hx } = c
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
g : Equiv.Perm α
c : { x // x ∈ Equiv.Perm.cycleFactorsFinset g }
vc : ↥(Subgroup.zpowers ↑c)
x : α
hx : Equiv.Perm.cycleOf g x ∈ Equiv.Perm.cycleFactorsFinset g
hc : ¬Equiv.Perm.cycleOf g x = ↑c
⊢ { val := Equiv.Perm.cycleOf g x, property := hx } ≠ c
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.