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/PermIwasawa.lean | Equiv.Perm.Equiv.Perm.normal_subgroups | [215, 1] | [241, 21] | norm_num | case refine'_1.hGX.h_one_le
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ 1 ≤ 2
case refine'_1.hGX.hn
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ 2 < Fintype.card α
case refine'_1.hGX.hα
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ Fintype.card α ≠ 2 * 2 | case refine'_1.hGX.hn
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ 2 < Fintype.card α
case refine'_1.hGX.hα
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ Fintype.card α ≠ 2 * 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case refine'_1.hGX.h_one_le
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ 1 ≤ 2
case refine'_1.hGX.hn
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ 2 < Fintype.card α
case refine'_1.hGX.hα
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ Fintype.card α ≠ 2 * 2
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermIwasawa.lean | Equiv.Perm.Equiv.Perm.normal_subgroups | [215, 1] | [241, 21] | apply lt_of_lt_of_le _ hα | case refine'_1.hGX.hn
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ 2 < Fintype.card α
case refine'_1.hGX.hα
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ Fintype.card α ≠ 2 * 2 | α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ 2 < 5
case refine'_1.hGX.hα
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ Fintype.card α ≠ 2 * 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case refine'_1.hGX.hn
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ 2 < Fintype.card α
case refine'_1.hGX.hα
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ Fintype.card α ≠ 2 * 2
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermIwasawa.lean | Equiv.Perm.Equiv.Perm.normal_subgroups | [215, 1] | [241, 21] | norm_num | α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ 2 < 5
case refine'_1.hGX.hα
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ Fintype.card α ≠ 2 * 2 | case refine'_1.hGX.hα
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ Fintype.card α ≠ 2 * 2 | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ 2 < 5
case refine'_1.hGX.hα
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ Fintype.card α ≠ 2 * 2
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermIwasawa.lean | Equiv.Perm.Equiv.Perm.normal_subgroups | [215, 1] | [241, 21] | apply ne_of_gt | case refine'_1.hGX.hα
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ Fintype.card α ≠ 2 * 2 | case refine'_1.hGX.hα.h
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ 2 * 2 < Fintype.card α | Please generate a tactic in lean4 to solve the state.
STATE:
case refine'_1.hGX.hα
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ Fintype.card α ≠ 2 * 2
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermIwasawa.lean | Equiv.Perm.Equiv.Perm.normal_subgroups | [215, 1] | [241, 21] | apply lt_of_lt_of_le _ hα | case refine'_1.hGX.hα.h
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ 2 * 2 < Fintype.card α | α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ 2 * 2 < 5 | Please generate a tactic in lean4 to solve the state.
STATE:
case refine'_1.hGX.hα.h
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ 2 * 2 < Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermIwasawa.lean | Equiv.Perm.Equiv.Perm.normal_subgroups | [215, 1] | [241, 21] | norm_num | α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ 2 * 2 < 5 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
⊢ 2 * 2 < 5
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermIwasawa.lean | Equiv.Perm.Equiv.Perm.normal_subgroups | [215, 1] | [241, 21] | norm_num | α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
h : fixedPoints ↥N ↑(Nat.Combination α 2) = ⊤
g : Perm α
hgN : g ∈ N
hg_ne : g ≠ 1
⊢ 1 ≤ 2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
h : fixedPoints ↥N ↑(Nat.Combination α 2) = ⊤
g : Perm α
hgN : g ∈ N
hg_ne : g ≠ 1
⊢ 1 ≤ 2
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermIwasawa.lean | Equiv.Perm.Equiv.Perm.normal_subgroups | [215, 1] | [241, 21] | rw [PartENat.card_eq_coe_fintype_card, PartENat.coe_le_coe] | α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
h : fixedPoints ↥N ↑(Nat.Combination α 2) = ⊤
g : Perm α
hgN : g ∈ N
hg_ne : g ≠ 1
⊢ ↑(Nat.succ 2) ≤ PartENat.card α | α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
h : fixedPoints ↥N ↑(Nat.Combination α 2) = ⊤
g : Perm α
hgN : g ∈ N
hg_ne : g ≠ 1
⊢ Nat.succ 2 ≤ Fintype.card α | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
h : fixedPoints ↥N ↑(Nat.Combination α 2) = ⊤
g : Perm α
hgN : g ∈ N
hg_ne : g ≠ 1
⊢ ↑(Nat.succ 2) ≤ PartENat.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermIwasawa.lean | Equiv.Perm.Equiv.Perm.normal_subgroups | [215, 1] | [241, 21] | apply le_trans (by norm_num) hα | α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
h : fixedPoints ↥N ↑(Nat.Combination α 2) = ⊤
g : Perm α
hgN : g ∈ N
hg_ne : g ≠ 1
⊢ Nat.succ 2 ≤ Fintype.card α | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
h : fixedPoints ↥N ↑(Nat.Combination α 2) = ⊤
g : Perm α
hgN : g ∈ N
hg_ne : g ≠ 1
⊢ Nat.succ 2 ≤ Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermIwasawa.lean | Equiv.Perm.Equiv.Perm.normal_subgroups | [215, 1] | [241, 21] | norm_num | α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
h : fixedPoints ↥N ↑(Nat.Combination α 2) = ⊤
g : Perm α
hgN : g ∈ N
hg_ne : g ≠ 1
⊢ Nat.succ 2 ≤ 5 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
h : fixedPoints ↥N ↑(Nat.Combination α 2) = ⊤
g : Perm α
hgN : g ∈ N
hg_ne : g ≠ 1
⊢ Nat.succ 2 ≤ 5
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermIwasawa.lean | Equiv.Perm.Equiv.Perm.normal_subgroups | [215, 1] | [241, 21] | exact hg_ne | α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
h : fixedPoints ↥N ↑(Nat.Combination α 2) = ⊤
g : Perm α
hgN : g ∈ N
hg_ne : g ≠ 1
⊢ toPerm g ≠ 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
h : fixedPoints ↥N ↑(Nat.Combination α 2) = ⊤
g : Perm α
hgN : g ∈ N
hg_ne : g ≠ 1
⊢ toPerm g ≠ 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermIwasawa.lean | Equiv.Perm.Equiv.Perm.normal_subgroups | [215, 1] | [241, 21] | rw [mem_fixedPoints] at this | α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
h : fixedPoints ↥N ↑(Nat.Combination α 2) = ⊤
g : Perm α
hgN : g ∈ N
hg_ne : g ≠ 1
s : ↑(Nat.Combination α 2)
hs : g • s ≠ s
this : s ∈ fixedPoints ↥N ↑(Nat.Combination α 2)
⊢ g • s = s | α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
h : fixedPoints ↥N ↑(Nat.Combination α 2) = ⊤
g : Perm α
hgN : g ∈ N
hg_ne : g ≠ 1
s : ↑(Nat.Combination α 2)
hs : g • s ≠ s
this : ∀ (m : ↥N), m • s = s
⊢ g • s = s | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
h : fixedPoints ↥N ↑(Nat.Combination α 2) = ⊤
g : Perm α
hgN : g ∈ N
hg_ne : g ≠ 1
s : ↑(Nat.Combination α 2)
hs : g • s ≠ s
this : s ∈ fixedPoints ↥N ↑(Nat.Combination α 2)
⊢ g • s = s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermIwasawa.lean | Equiv.Perm.Equiv.Perm.normal_subgroups | [215, 1] | [241, 21] | exact this ⟨g, hgN⟩ | α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
h : fixedPoints ↥N ↑(Nat.Combination α 2) = ⊤
g : Perm α
hgN : g ∈ N
hg_ne : g ≠ 1
s : ↑(Nat.Combination α 2)
hs : g • s ≠ s
this : ∀ (m : ↥N), m • s = s
⊢ g • s = s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type ?u.55854
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hα : 5 ≤ Fintype.card α
N : Subgroup (Perm α)
hnN : Subgroup.Normal N
ntN : Nontrivial ↥N
h : fixedPoints ↥N ↑(Nat.Combination α 2) = ⊤
g : Perm α
hgN : g ∈ N
hg_ne : g ≠ 1
s : ↑(Nat.Combination α 2)
hs : g • s ≠ s
this : ∀ (m : ↥N), m • s = s
⊢ g • s = s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.Perm.disjoint_iff_support_disjoint | [224, 1] | [230, 61] | simp only [Equiv.Perm.disjoint_iff_eq_or_eq,
Finset.disjoint_iff_inter_eq_empty, ← Equiv.Perm.not_mem_support,
← Finset.mem_compl, ← Finset.mem_union, ← Finset.compl_inter,
← Finset.compl_eq_univ_iff, ← Finset.eq_univ_iff_forall] | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
f g : Perm α
⊢ Disjoint f g ↔ _root_.Disjoint (support f) (support g) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
f g : Perm α
⊢ Disjoint f g ↔ _root_.Disjoint (support f) (support g)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.Perm.eq_cycleOf_of_mem_cycleFactorsFinset_iff | [233, 1] | [241, 54] | constructor | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
g c : Perm α
hc : c ∈ cycleFactorsFinset g
x : α
⊢ c = cycleOf g x ↔ x ∈ support c | case mp
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
g c : Perm α
hc : c ∈ cycleFactorsFinset g
x : α
⊢ c = cycleOf g x → x ∈ support c
case mpr
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
g c : Perm α
hc : c ∈ cycleFactorsFinset g
x : α
⊢ x ∈ support c → c = cycleOf g x | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
g c : Perm α
hc : c ∈ cycleFactorsFinset g
x : α
⊢ c = cycleOf g x ↔ x ∈ support c
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.Perm.eq_cycleOf_of_mem_cycleFactorsFinset_iff | [233, 1] | [241, 54] | intro hcx | case mp
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
g c : Perm α
hc : c ∈ cycleFactorsFinset g
x : α
⊢ c = cycleOf g x → x ∈ support c | case mp
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
g c : Perm α
hc : c ∈ cycleFactorsFinset g
x : α
hcx : c = cycleOf g x
⊢ x ∈ support c | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
g c : Perm α
hc : c ∈ cycleFactorsFinset g
x : α
⊢ c = cycleOf g x → x ∈ support c
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.Perm.eq_cycleOf_of_mem_cycleFactorsFinset_iff | [233, 1] | [241, 54] | rw [Equiv.Perm.mem_support, hcx, Equiv.Perm.cycleOf_apply_self,
Ne.def, ← Equiv.Perm.cycleOf_eq_one_iff, ← hcx] | case mp
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
g c : Perm α
hc : c ∈ cycleFactorsFinset g
x : α
hcx : c = cycleOf g x
⊢ x ∈ support c | case mp
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
g c : Perm α
hc : c ∈ cycleFactorsFinset g
x : α
hcx : c = cycleOf g x
⊢ ¬c = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
g c : Perm α
hc : c ∈ cycleFactorsFinset g
x : α
hcx : c = cycleOf g x
⊢ x ∈ support c
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.Perm.eq_cycleOf_of_mem_cycleFactorsFinset_iff | [233, 1] | [241, 54] | exact Equiv.Perm.IsCycle.ne_one (Equiv.Perm.mem_cycleFactorsFinset_iff.mp hc).left | case mp
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
g c : Perm α
hc : c ∈ cycleFactorsFinset g
x : α
hcx : c = cycleOf g x
⊢ ¬c = 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
g c : Perm α
hc : c ∈ cycleFactorsFinset g
x : α
hcx : c = cycleOf g x
⊢ ¬c = 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.Perm.eq_cycleOf_of_mem_cycleFactorsFinset_iff | [233, 1] | [241, 54] | intro hx | case mpr
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
g c : Perm α
hc : c ∈ cycleFactorsFinset g
x : α
⊢ x ∈ support c → c = cycleOf g x | case mpr
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
g c : Perm α
hc : c ∈ cycleFactorsFinset g
x : α
hx : x ∈ support c
⊢ c = cycleOf g x | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
g c : Perm α
hc : c ∈ cycleFactorsFinset g
x : α
⊢ x ∈ support c → c = cycleOf g x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.Perm.eq_cycleOf_of_mem_cycleFactorsFinset_iff | [233, 1] | [241, 54] | exact Equiv.Perm.cycle_is_cycleOf hx hc | case mpr
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
g c : Perm α
hc : c ∈ cycleFactorsFinset g
x : α
hx : x ∈ support c
⊢ c = cycleOf g x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
g c : Perm α
hc : c ∈ cycleFactorsFinset g
x : α
hx : x ∈ support c
⊢ c = cycleOf g x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | induction' s using Finset.induction with a s has ih | ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
s : Finset ι
k : κ
⊢ ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val) | case empty
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
⊢ ncard {x | x ∈ ∅ ∧ f x = k} = Multiset.count k (Multiset.map f ∅.val)
case insert
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
⊢ ncard {x | x ∈ insert a s ∧ f x = k} = Multiset.count k (Multiset.map f (insert a s).val) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
s : Finset ι
k : κ
⊢ ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | simp | case empty
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
⊢ ncard {x | x ∈ ∅ ∧ f x = k} = Multiset.count k (Multiset.map f ∅.val) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case empty
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
⊢ ncard {x | x ∈ ∅ ∧ f x = k} = Multiset.count k (Multiset.map f ∅.val)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | ext x | case insert
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
⊢ {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k} | case insert.h
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
⊢ x ∈ {x | x ∈ insert a s ∧ f x = k} ↔ x ∈ if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k} | Please generate a tactic in lean4 to solve the state.
STATE:
case insert
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
⊢ {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | simp only [Finset.mem_insert, Set.mem_setOf_eq] | case insert.h
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
⊢ x ∈ {x | x ∈ insert a s ∧ f x = k} ↔ x ∈ if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k} | case insert.h
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
⊢ (x = a ∨ x ∈ s) ∧ f x = k ↔ x ∈ if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k} | Please generate a tactic in lean4 to solve the state.
STATE:
case insert.h
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
⊢ x ∈ {x | x ∈ insert a s ∧ f x = k} ↔ x ∈ if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | by_cases h : f a = k | case insert.h
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
⊢ (x = a ∨ x ∈ s) ∧ f x = k ↔ x ∈ if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k} | case pos
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
h : f a = k
⊢ (x = a ∨ x ∈ s) ∧ f x = k ↔ x ∈ if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
case neg
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
h : ¬f a = k
⊢ (x = a ∨ x ∈ s) ∧ f x = k ↔ x ∈ if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k} | Please generate a tactic in lean4 to solve the state.
STATE:
case insert.h
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
⊢ (x = a ∨ x ∈ s) ∧ f x = k ↔ x ∈ if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | rw [this] | ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
⊢ ncard {x | x ∈ insert a s ∧ f x = k} = Multiset.count k (Multiset.map f (insert a s).val) | ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
⊢ ncard (if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}) =
Multiset.count k (Multiset.map f (insert a s).val) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
⊢ ncard {x | x ∈ insert a s ∧ f x = k} = Multiset.count k (Multiset.map f (insert a s).val)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | simp only [Finset.insert_val, Finset.mem_val, Multiset.mem_map, Multiset.mem_ndinsert, exists_eq_or_imp, Multiset.ndinsert_of_not_mem has] | ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
⊢ ncard (if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}) =
Multiset.count k (Multiset.map f (insert a s).val) | ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
⊢ ncard (if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}) =
Multiset.count k (Multiset.map (fun x => f x) (a ::ₘ s.val)) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
⊢ ncard (if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}) =
Multiset.count k (Multiset.map f (insert a s).val)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | simp only [Multiset.map_cons, Multiset.mem_cons, Multiset.mem_map, Finset.mem_val,
Multiset.nodup_cons, not_exists, not_and, ne_eq] | ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
⊢ ncard (if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}) =
Multiset.count k (Multiset.map (fun x => f x) (a ::ₘ s.val)) | ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
⊢ ncard (if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}) =
Multiset.count k (f a ::ₘ Multiset.map (fun x => f x) s.val) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
⊢ ncard (if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}) =
Multiset.count k (Multiset.map (fun x => f x) (a ::ₘ s.val))
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | rw [Multiset.count_cons] | ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
⊢ ncard (if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}) =
Multiset.count k (f a ::ₘ Multiset.map (fun x => f x) s.val) | ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
⊢ ncard (if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}) =
Multiset.count k (Multiset.map (fun x => f x) s.val) + if k = f a then 1 else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
⊢ ncard (if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}) =
Multiset.count k (f a ::ₘ Multiset.map (fun x => f x) s.val)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | by_cases h : f a = k | ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
⊢ ncard (if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}) =
Multiset.count k (Multiset.map (fun x => f x) s.val) + if k = f a then 1 else 0 | case pos
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ ncard (if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}) =
Multiset.count k (Multiset.map (fun x => f x) s.val) + if k = f a then 1 else 0
case neg
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : ¬f a = k
⊢ ncard (if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}) =
Multiset.count k (Multiset.map (fun x => f x) s.val) + if k = f a then 1 else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
⊢ ncard (if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}) =
Multiset.count k (Multiset.map (fun x => f x) s.val) + if k = f a then 1 else 0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | rw [if_pos h, if_pos h.symm] | case pos
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ ncard (if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}) =
Multiset.count k (Multiset.map (fun x => f x) s.val) + if k = f a then 1 else 0 | case pos
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ ncard (insert a {x | x ∈ s ∧ f x = k}) = Multiset.count k (Multiset.map (fun x => f x) s.val) + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ ncard (if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}) =
Multiset.count k (Multiset.map (fun x => f x) s.val) + if k = f a then 1 else 0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | rw [Set.ncard_insert_of_not_mem ?_ ?_] | case pos
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ ncard (insert a {x | x ∈ s ∧ f x = k}) = Multiset.count k (Multiset.map (fun x => f x) s.val) + 1 | case pos
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ ncard {x | x ∈ s ∧ f x = k} + 1 = Multiset.count k (Multiset.map (fun x => f x) s.val) + 1
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ a ∉ {x | x ∈ s ∧ f x = k}
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ Set.Finite {x | x ∈ s ∧ f x = k} | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ ncard (insert a {x | x ∈ s ∧ f x = k}) = Multiset.count k (Multiset.map (fun x => f x) s.val) + 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | simp only [add_left_inj, ih] | case pos
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ ncard {x | x ∈ s ∧ f x = k} + 1 = Multiset.count k (Multiset.map (fun x => f x) s.val) + 1
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ a ∉ {x | x ∈ s ∧ f x = k}
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ Set.Finite {x | x ∈ s ∧ f x = k} | ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ a ∉ {x | x ∈ s ∧ f x = k}
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ Set.Finite {x | x ∈ s ∧ f x = k} | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ ncard {x | x ∈ s ∧ f x = k} + 1 = Multiset.count k (Multiset.map (fun x => f x) s.val) + 1
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ a ∉ {x | x ∈ s ∧ f x = k}
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ Set.Finite {x | x ∈ s ∧ f x = k}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | simp only [Set.mem_setOf_eq] | ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ a ∉ {x | x ∈ s ∧ f x = k} | ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ ¬(a ∈ s ∧ f a = k) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ a ∉ {x | x ∈ s ∧ f x = k}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | intro ha | ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ ¬(a ∈ s ∧ f a = k) | ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
ha : a ∈ s ∧ f a = k
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ ¬(a ∈ s ∧ f a = k)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | exact has ha.1 | ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
ha : a ∈ s ∧ f a = k
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
ha : a ∈ s ∧ f a = k
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | apply Set.Finite.subset s.finite_toSet | ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ Set.Finite {x | x ∈ s ∧ f x = k} | ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ {x | x ∈ s ∧ f x = k} ⊆ ↑s | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ Set.Finite {x | x ∈ s ∧ f x = k}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | intro x | ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ {x | x ∈ s ∧ f x = k} ⊆ ↑s | ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
x : ι
⊢ x ∈ {x | x ∈ s ∧ f x = k} → x ∈ ↑s | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
⊢ {x | x ∈ s ∧ f x = k} ⊆ ↑s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | simp only [Set.mem_setOf_eq, Finset.mem_coe, and_imp] | ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
x : ι
⊢ x ∈ {x | x ∈ s ∧ f x = k} → x ∈ ↑s | ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
x : ι
⊢ x ∈ s → f x = k → x ∈ s | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
x : ι
⊢ x ∈ {x | x ∈ s ∧ f x = k} → x ∈ ↑s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | intro hx _ | ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
x : ι
⊢ x ∈ s → f x = k → x ∈ s | ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
x : ι
hx : x ∈ s
a✝ : f x = k
⊢ x ∈ s | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
x : ι
⊢ x ∈ s → f x = k → x ∈ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | exact hx | ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
x : ι
hx : x ∈ s
a✝ : f x = k
⊢ x ∈ s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : f a = k
x : ι
hx : x ∈ s
a✝ : f x = k
⊢ x ∈ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | rw [if_neg h, if_neg (ne_comm.mp h), ih, add_zero] | case neg
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : ¬f a = k
⊢ ncard (if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}) =
Multiset.count k (Multiset.map (fun x => f x) s.val) + if k = f a then 1 else 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
this : {x | x ∈ insert a s ∧ f x = k} = if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
h : ¬f a = k
⊢ ncard (if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}) =
Multiset.count k (Multiset.map (fun x => f x) s.val) + if k = f a then 1 else 0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | simp only [Set.mem_setOf_eq, if_pos h, Set.mem_insert_iff] | case pos
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
h : f a = k
⊢ (x = a ∨ x ∈ s) ∧ f x = k ↔ x ∈ if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k} | case pos
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
h : f a = k
⊢ (x = a ∨ x ∈ s) ∧ f x = k ↔ x = a ∨ x ∈ s ∧ f x = k | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
h : f a = k
⊢ (x = a ∨ x ∈ s) ∧ f x = k ↔ x ∈ if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | aesop | case pos
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
h : f a = k
⊢ (x = a ∨ x ∈ s) ∧ f x = k ↔ x = a ∨ x ∈ s ∧ f x = k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
h : f a = k
⊢ (x = a ∨ x ∈ s) ∧ f x = k ↔ x = a ∨ x ∈ s ∧ f x = k
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | simp only [Set.mem_setOf_eq, if_neg h, and_congr_left_iff, or_iff_right_iff_imp] | case neg
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
h : ¬f a = k
⊢ (x = a ∨ x ∈ s) ∧ f x = k ↔ x ∈ if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k} | case neg
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
h : ¬f a = k
⊢ f x = k → x = a → x ∈ s | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
h : ¬f a = k
⊢ (x = a ∨ x ∈ s) ∧ f x = k ↔ x ∈ if f a = k then insert a {x | x ∈ s ∧ f x = k} else {x | x ∈ s ∧ f x = k}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | intro hx hxa | case neg
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
h : ¬f a = k
⊢ f x = k → x = a → x ∈ s | case neg
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
h : ¬f a = k
hx : f x = k
hxa : x = a
⊢ x ∈ s | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
h : ¬f a = k
⊢ f x = k → x = a → x ∈ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | exfalso | case neg
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
h : ¬f a = k
hx : f x = k
hxa : x = a
⊢ x ∈ s | case neg
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
h : ¬f a = k
hx : f x = k
hxa : x = a
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
h : ¬f a = k
hx : f x = k
hxa : x = a
⊢ x ∈ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | apply h | case neg
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
h : ¬f a = k
hx : f x = k
hxa : x = a
⊢ False | case neg
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
h : ¬f a = k
hx : f x = k
hxa : x = a
⊢ f a = k | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
h : ¬f a = k
hx : f x = k
hxa : x = a
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Set.ncard_filter_eq_count | [399, 1] | [433, 21] | rw [← hxa, hx] | case neg
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
h : ¬f a = k
hx : f x = k
hxa : x = a
⊢ f a = k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type u_1
κ : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq κ
f : ι → κ
k : κ
a : ι
s : Finset ι
has : a ∉ s
ih : ncard {x | x ∈ s ∧ f x = k} = Multiset.count k (Multiset.map f s.val)
x : ι
h : ¬f a = k
hx : f x = k
hxa : x = a
⊢ f a = k
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Multiset.prod_toFinset | [456, 1] | [462, 73] | induction' m using Multiset.induction with a m ih | α : Type u_1
M : Type u_2
inst✝¹ : DecidableEq α
inst✝ : CommMonoid M
f : α → M
m : Multiset α
hm : Nodup m
⊢ Finset.prod (toFinset m) f = prod (map f m) | case empty
α : Type u_1
M : Type u_2
inst✝¹ : DecidableEq α
inst✝ : CommMonoid M
f : α → M
hm : Nodup 0
⊢ Finset.prod (toFinset 0) f = prod (map f 0)
case cons
α : Type u_1
M : Type u_2
inst✝¹ : DecidableEq α
inst✝ : CommMonoid M
f : α → M
a : α
m : Multiset α
ih : Nodup m → Finset.prod (toFinset m) f = prod (map f m)
hm : Nodup (a ::ₘ m)
⊢ Finset.prod (toFinset (a ::ₘ m)) f = prod (map f (a ::ₘ m)) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
M : Type u_2
inst✝¹ : DecidableEq α
inst✝ : CommMonoid M
f : α → M
m : Multiset α
hm : Nodup m
⊢ Finset.prod (toFinset m) f = prod (map f m)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Multiset.prod_toFinset | [456, 1] | [462, 73] | simp | case empty
α : Type u_1
M : Type u_2
inst✝¹ : DecidableEq α
inst✝ : CommMonoid M
f : α → M
hm : Nodup 0
⊢ Finset.prod (toFinset 0) f = prod (map f 0)
case cons
α : Type u_1
M : Type u_2
inst✝¹ : DecidableEq α
inst✝ : CommMonoid M
f : α → M
a : α
m : Multiset α
ih : Nodup m → Finset.prod (toFinset m) f = prod (map f m)
hm : Nodup (a ::ₘ m)
⊢ Finset.prod (toFinset (a ::ₘ m)) f = prod (map f (a ::ₘ m)) | case cons
α : Type u_1
M : Type u_2
inst✝¹ : DecidableEq α
inst✝ : CommMonoid M
f : α → M
a : α
m : Multiset α
ih : Nodup m → Finset.prod (toFinset m) f = prod (map f m)
hm : Nodup (a ::ₘ m)
⊢ Finset.prod (toFinset (a ::ₘ m)) f = prod (map f (a ::ₘ m)) | Please generate a tactic in lean4 to solve the state.
STATE:
case empty
α : Type u_1
M : Type u_2
inst✝¹ : DecidableEq α
inst✝ : CommMonoid M
f : α → M
hm : Nodup 0
⊢ Finset.prod (toFinset 0) f = prod (map f 0)
case cons
α : Type u_1
M : Type u_2
inst✝¹ : DecidableEq α
inst✝ : CommMonoid M
f : α → M
a : α
m : Multiset α
ih : Nodup m → Finset.prod (toFinset m) f = prod (map f m)
hm : Nodup (a ::ₘ m)
⊢ Finset.prod (toFinset (a ::ₘ m)) f = prod (map f (a ::ₘ m))
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Multiset.prod_toFinset | [456, 1] | [462, 73] | obtain ⟨not_mem, hm⟩ := Multiset.nodup_cons.mp hm | case cons
α : Type u_1
M : Type u_2
inst✝¹ : DecidableEq α
inst✝ : CommMonoid M
f : α → M
a : α
m : Multiset α
ih : Nodup m → Finset.prod (toFinset m) f = prod (map f m)
hm : Nodup (a ::ₘ m)
⊢ Finset.prod (toFinset (a ::ₘ m)) f = prod (map f (a ::ₘ m)) | case cons.intro
α : Type u_1
M : Type u_2
inst✝¹ : DecidableEq α
inst✝ : CommMonoid M
f : α → M
a : α
m : Multiset α
ih : Nodup m → Finset.prod (toFinset m) f = prod (map f m)
hm✝ : Nodup (a ::ₘ m)
not_mem : a ∉ m
hm : Nodup m
⊢ Finset.prod (toFinset (a ::ₘ m)) f = prod (map f (a ::ₘ m)) | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
α : Type u_1
M : Type u_2
inst✝¹ : DecidableEq α
inst✝ : CommMonoid M
f : α → M
a : α
m : Multiset α
ih : Nodup m → Finset.prod (toFinset m) f = prod (map f m)
hm : Nodup (a ::ₘ m)
⊢ Finset.prod (toFinset (a ::ₘ m)) f = prod (map f (a ::ₘ m))
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Multiset.prod_toFinset | [456, 1] | [462, 73] | simp [Finset.prod_insert (mt Multiset.mem_toFinset.mp not_mem), ih hm] | case cons.intro
α : Type u_1
M : Type u_2
inst✝¹ : DecidableEq α
inst✝ : CommMonoid M
f : α → M
a : α
m : Multiset α
ih : Nodup m → Finset.prod (toFinset m) f = prod (map f m)
hm✝ : Nodup (a ::ₘ m)
not_mem : a ∉ m
hm : Nodup m
⊢ Finset.prod (toFinset (a ::ₘ m)) f = prod (map f (a ::ₘ m)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.intro
α : Type u_1
M : Type u_2
inst✝¹ : DecidableEq α
inst✝ : CommMonoid M
f : α → M
a : α
m : Multiset α
ih : Nodup m → Finset.prod (toFinset m) f = prod (map f m)
hm✝ : Nodup (a ::ₘ m)
not_mem : a ∉ m
hm : Nodup m
⊢ Finset.prod (toFinset (a ::ₘ m)) f = prod (map f (a ::ₘ m))
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_empty | [482, 1] | [490, 46] | apply Finset.eq_empty_of_forall_not_mem | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
⊢ permWithCycleType α c = ∅ | case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
⊢ ∀ (x : Perm α), x ∉ permWithCycleType α c | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
⊢ permWithCycleType α c = ∅
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_empty | [482, 1] | [490, 46] | intro g | case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
⊢ ∀ (x : Perm α), x ∉ permWithCycleType α c | case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
g : Perm α
⊢ g ∉ permWithCycleType α c | Please generate a tactic in lean4 to solve the state.
STATE:
case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
⊢ ∀ (x : Perm α), x ∉ permWithCycleType α c
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_empty | [482, 1] | [490, 46] | unfold Equiv.permWithCycleType | case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
g : Perm α
⊢ g ∉ permWithCycleType α c | case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
g : Perm α
⊢ g ∉ Finset.filter (fun g => Perm.cycleType g = c) Finset.univ | Please generate a tactic in lean4 to solve the state.
STATE:
case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
g : Perm α
⊢ g ∉ permWithCycleType α c
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_empty | [482, 1] | [490, 46] | simp only [Set.toFinset_univ, Finset.mem_filter, Finset.mem_univ, true_and_iff] | case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
g : Perm α
⊢ g ∉ Finset.filter (fun g => Perm.cycleType g = c) Finset.univ | case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
g : Perm α
⊢ ¬Perm.cycleType g = c | Please generate a tactic in lean4 to solve the state.
STATE:
case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
g : Perm α
⊢ g ∉ Finset.filter (fun g => Perm.cycleType g = c) Finset.univ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_empty | [482, 1] | [490, 46] | intro hg | case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
g : Perm α
⊢ ¬Perm.cycleType g = c | case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
g : Perm α
hg : Perm.cycleType g = c
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
g : Perm α
⊢ ¬Perm.cycleType g = c
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_empty | [482, 1] | [490, 46] | apply lt_iff_not_le.mp hc | case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
g : Perm α
hg : Perm.cycleType g = c
⊢ False | case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
g : Perm α
hg : Perm.cycleType g = c
⊢ Multiset.sum c ≤ Fintype.card α | Please generate a tactic in lean4 to solve the state.
STATE:
case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
g : Perm α
hg : Perm.cycleType g = c
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_empty | [482, 1] | [490, 46] | rw [← hg] | case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
g : Perm α
hg : Perm.cycleType g = c
⊢ Multiset.sum c ≤ Fintype.card α | case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
g : Perm α
hg : Perm.cycleType g = c
⊢ Multiset.sum (Perm.cycleType g) ≤ Fintype.card α | Please generate a tactic in lean4 to solve the state.
STATE:
case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
g : Perm α
hg : Perm.cycleType g = c
⊢ Multiset.sum c ≤ Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_empty | [482, 1] | [490, 46] | rw [Equiv.Perm.sum_cycleType] | case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
g : Perm α
hg : Perm.cycleType g = c
⊢ Multiset.sum (Perm.cycleType g) ≤ Fintype.card α | case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
g : Perm α
hg : Perm.cycleType g = c
⊢ (Perm.support g).card ≤ Fintype.card α | Please generate a tactic in lean4 to solve the state.
STATE:
case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
g : Perm α
hg : Perm.cycleType g = c
⊢ Multiset.sum (Perm.cycleType g) ≤ Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_empty | [482, 1] | [490, 46] | refine' (Equiv.Perm.support g).card_le_univ | case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
g : Perm α
hg : Perm.cycleType g = c
⊢ (Perm.support g).card ≤ Fintype.card α | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Multiset ℕ
hc : Fintype.card α < Multiset.sum c
g : Perm α
hg : Perm.cycleType g = c
⊢ (Perm.support g).card ≤ Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | constructor | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
⊢ (permWithCycleType α m).Nonempty ↔ Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a | case mp
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
⊢ (permWithCycleType α m).Nonempty → Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a
case mpr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
⊢ (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) → (permWithCycleType α m).Nonempty | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
⊢ (permWithCycleType α m).Nonempty ↔ Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | intro h | case mp
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
⊢ (permWithCycleType α m).Nonempty → Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a | case mp
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
h : (permWithCycleType α m).Nonempty
⊢ Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
⊢ (permWithCycleType α m).Nonempty → Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | obtain ⟨g, hg⟩ := h | case mp
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
h : (permWithCycleType α m).Nonempty
⊢ Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a | case mp.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : g ∈ permWithCycleType α m
⊢ Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
h : (permWithCycleType α m).Nonempty
⊢ Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | simp only [Equiv.permWithCycleType, Set.toFinset_univ, Finset.mem_filter,
Finset.mem_univ, true_and_iff] at hg | case mp.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : g ∈ permWithCycleType α m
⊢ Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a | case mp.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : Perm.cycleType g = m
⊢ Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : g ∈ permWithCycleType α m
⊢ Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | constructor | case mp.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : Perm.cycleType g = m
⊢ Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a | case mp.intro.left
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : Perm.cycleType g = m
⊢ Multiset.sum m ≤ Fintype.card α
case mp.intro.right
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : Perm.cycleType g = m
⊢ ∀ a ∈ m, 2 ≤ a | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : Perm.cycleType g = m
⊢ Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | rw [← hg, Equiv.Perm.sum_cycleType] | case mp.intro.left
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : Perm.cycleType g = m
⊢ Multiset.sum m ≤ Fintype.card α
case mp.intro.right
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : Perm.cycleType g = m
⊢ ∀ a ∈ m, 2 ≤ a | case mp.intro.left
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : Perm.cycleType g = m
⊢ (Perm.support g).card ≤ Fintype.card α
case mp.intro.right
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : Perm.cycleType g = m
⊢ ∀ a ∈ m, 2 ≤ a | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.intro.left
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : Perm.cycleType g = m
⊢ Multiset.sum m ≤ Fintype.card α
case mp.intro.right
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : Perm.cycleType g = m
⊢ ∀ a ∈ m, 2 ≤ a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | exact (Equiv.Perm.support g).card_le_univ | case mp.intro.left
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : Perm.cycleType g = m
⊢ (Perm.support g).card ≤ Fintype.card α
case mp.intro.right
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : Perm.cycleType g = m
⊢ ∀ a ∈ m, 2 ≤ a | case mp.intro.right
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : Perm.cycleType g = m
⊢ ∀ a ∈ m, 2 ≤ a | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.intro.left
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : Perm.cycleType g = m
⊢ (Perm.support g).card ≤ Fintype.card α
case mp.intro.right
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : Perm.cycleType g = m
⊢ ∀ a ∈ m, 2 ≤ a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | intro a | case mp.intro.right
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : Perm.cycleType g = m
⊢ ∀ a ∈ m, 2 ≤ a | case mp.intro.right
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : Perm.cycleType g = m
a : ℕ
⊢ a ∈ m → 2 ≤ a | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.intro.right
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : Perm.cycleType g = m
⊢ ∀ a ∈ m, 2 ≤ a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | rw [← hg] | case mp.intro.right
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : Perm.cycleType g = m
a : ℕ
⊢ a ∈ m → 2 ≤ a | case mp.intro.right
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : Perm.cycleType g = m
a : ℕ
⊢ a ∈ Perm.cycleType g → 2 ≤ a | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.intro.right
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : Perm.cycleType g = m
a : ℕ
⊢ a ∈ m → 2 ≤ a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | exact Equiv.Perm.two_le_of_mem_cycleType | case mp.intro.right
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : Perm.cycleType g = m
a : ℕ
⊢ a ∈ Perm.cycleType g → 2 ≤ a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.intro.right
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
g : Perm α
hg : Perm.cycleType g = m
a : ℕ
⊢ a ∈ Perm.cycleType g → 2 ≤ a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | rintro ⟨hc, h2c⟩ | case mpr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
⊢ (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) → (permWithCycleType α m).Nonempty | case mpr.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
⊢ (permWithCycleType α m).Nonempty | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
⊢ (Multiset.sum m ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) → (permWithCycleType α m).Nonempty
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | have hc' : m.toList.sum ≤ Fintype.card α := by
simp only [Multiset.sum_toList]
exact hc | case mpr.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
⊢ (permWithCycleType α m).Nonempty | case mpr.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
⊢ (permWithCycleType α m).Nonempty | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
⊢ (permWithCycleType α m).Nonempty
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | obtain ⟨p, hp_length, hp_nodup, hp_disj⟩ := List.exists_pw_disjoint_with_card hc' | case mpr.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
⊢ (permWithCycleType α m).Nonempty | case mpr.intro.intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
⊢ (permWithCycleType α m).Nonempty | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
⊢ (permWithCycleType α m).Nonempty
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | use List.prod (List.map (fun l => List.formPerm l) p) | case mpr.intro.intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
⊢ (permWithCycleType α m).Nonempty | case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
⊢ List.prod (List.map (fun l => List.formPerm l) p) ∈ permWithCycleType α m | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.intro.intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
⊢ (permWithCycleType α m).Nonempty
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | simp only [Equiv.permWithCycleType, Finset.mem_filter, Set.toFinset_univ,
Finset.mem_univ, true_and_iff] | case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
⊢ List.prod (List.map (fun l => List.formPerm l) p) ∈ permWithCycleType α m | case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
⊢ Perm.cycleType (List.prod (List.map (fun l => List.formPerm l) p)) = m | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
⊢ List.prod (List.map (fun l => List.formPerm l) p) ∈ permWithCycleType α m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | have hp2 : ∀ x ∈ p, 2 ≤ x.length :=
by
intro x hx
apply h2c x.length
rw [← Multiset.mem_toList, ← hp_length, List.mem_map]
exact ⟨x, hx, rfl⟩ | case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
⊢ Perm.cycleType (List.prod (List.map (fun l => List.formPerm l) p)) = m | case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
⊢ Perm.cycleType (List.prod (List.map (fun l => List.formPerm l) p)) = m | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
⊢ Perm.cycleType (List.prod (List.map (fun l => List.formPerm l) p)) = m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | rw [Equiv.Perm.cycleType_eq _ rfl] | case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
⊢ Perm.cycleType (List.prod (List.map (fun l => List.formPerm l) p)) = m | case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
⊢ ↑(List.map (Finset.card ∘ Perm.support) (List.map (fun l => List.formPerm l) p)) = m
case h.h1
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
⊢ ∀ σ ∈ List.map (fun l => List.formPerm l) p, Perm.IsCycle σ
case h.h2
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
⊢ List.Pairwise Perm.Disjoint (List.map (fun l => List.formPerm l) p) | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
⊢ Perm.cycleType (List.prod (List.map (fun l => List.formPerm l) p)) = m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | simp only [Multiset.sum_toList] | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
⊢ List.sum (Multiset.toList m) ≤ Fintype.card α | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
⊢ Multiset.sum m ≤ Fintype.card α | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
⊢ List.sum (Multiset.toList m) ≤ Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | exact hc | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
⊢ Multiset.sum m ≤ Fintype.card α | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
⊢ Multiset.sum m ≤ Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | intro x hx | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
⊢ ∀ x ∈ p, 2 ≤ List.length x | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
x : List α
hx : x ∈ p
⊢ 2 ≤ List.length x | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
⊢ ∀ x ∈ p, 2 ≤ List.length x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | apply h2c x.length | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
x : List α
hx : x ∈ p
⊢ 2 ≤ List.length x | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
x : List α
hx : x ∈ p
⊢ List.length x ∈ m | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
x : List α
hx : x ∈ p
⊢ 2 ≤ List.length x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | rw [← Multiset.mem_toList, ← hp_length, List.mem_map] | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
x : List α
hx : x ∈ p
⊢ List.length x ∈ m | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
x : List α
hx : x ∈ p
⊢ ∃ a ∈ p, List.length a = List.length x | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
x : List α
hx : x ∈ p
⊢ List.length x ∈ m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | exact ⟨x, hx, rfl⟩ | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
x : List α
hx : x ∈ p
⊢ ∃ a ∈ p, List.length a = List.length x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
x : List α
hx : x ∈ p
⊢ ∃ a ∈ p, List.length a = List.length x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | rw [← Multiset.coe_toList m] | case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
⊢ ↑(List.map (Finset.card ∘ Perm.support) (List.map (fun l => List.formPerm l) p)) = m | case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
⊢ ↑(List.map (Finset.card ∘ Perm.support) (List.map (fun l => List.formPerm l) p)) = ↑(Multiset.toList m) | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
⊢ ↑(List.map (Finset.card ∘ Perm.support) (List.map (fun l => List.formPerm l) p)) = m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | apply congr_arg | case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
⊢ ↑(List.map (Finset.card ∘ Perm.support) (List.map (fun l => List.formPerm l) p)) = ↑(Multiset.toList m) | case h.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
⊢ List.map (Finset.card ∘ Perm.support) (List.map (fun l => List.formPerm l) p) = Multiset.toList m | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
⊢ ↑(List.map (Finset.card ∘ Perm.support) (List.map (fun l => List.formPerm l) p)) = ↑(Multiset.toList m)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | rw [List.map_map] | case h.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
⊢ List.map (Finset.card ∘ Perm.support) (List.map (fun l => List.formPerm l) p) = Multiset.toList m | case h.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
⊢ List.map ((Finset.card ∘ Perm.support) ∘ fun l => List.formPerm l) p = Multiset.toList m | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
⊢ List.map (Finset.card ∘ Perm.support) (List.map (fun l => List.formPerm l) p) = Multiset.toList m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | rw [← hp_length] | case h.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
⊢ List.map ((Finset.card ∘ Perm.support) ∘ fun l => List.formPerm l) p = Multiset.toList m | case h.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
⊢ List.map ((Finset.card ∘ Perm.support) ∘ fun l => List.formPerm l) p = List.map List.length p | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
⊢ List.map ((Finset.card ∘ Perm.support) ∘ fun l => List.formPerm l) p = Multiset.toList m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | apply List.map_congr | case h.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
⊢ List.map ((Finset.card ∘ Perm.support) ∘ fun l => List.formPerm l) p = List.map List.length p | case h.h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
⊢ ∀ x ∈ p, ((Finset.card ∘ Perm.support) ∘ fun l => List.formPerm l) x = List.length x | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
⊢ List.map ((Finset.card ∘ Perm.support) ∘ fun l => List.formPerm l) p = List.map List.length p
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | intro x hx | case h.h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
⊢ ∀ x ∈ p, ((Finset.card ∘ Perm.support) ∘ fun l => List.formPerm l) x = List.length x | case h.h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
x : List α
hx : x ∈ p
⊢ ((Finset.card ∘ Perm.support) ∘ fun l => List.formPerm l) x = List.length x | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
⊢ ∀ x ∈ p, ((Finset.card ∘ Perm.support) ∘ fun l => List.formPerm l) x = List.length x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | simp only [Function.comp_apply] | case h.h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
x : List α
hx : x ∈ p
⊢ ((Finset.card ∘ Perm.support) ∘ fun l => List.formPerm l) x = List.length x | case h.h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
x : List α
hx : x ∈ p
⊢ (Perm.support (List.formPerm x)).card = List.length x | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
x : List α
hx : x ∈ p
⊢ ((Finset.card ∘ Perm.support) ∘ fun l => List.formPerm l) x = List.length x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | rw [List.support_formPerm_of_nodup x (hp_nodup x hx)] | case h.h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
x : List α
hx : x ∈ p
⊢ (Perm.support (List.formPerm x)).card = List.length x | case h.h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
x : List α
hx : x ∈ p
⊢ (List.toFinset x).card = List.length x
case h.h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
x : List α
hx : x ∈ p
⊢ ∀ (x_1 : α), x ≠ [x_1] | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
x : List α
hx : x ∈ p
⊢ (Perm.support (List.formPerm x)).card = List.length x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | rw [List.toFinset_card_of_nodup (hp_nodup x hx)] | case h.h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
x : List α
hx : x ∈ p
⊢ (List.toFinset x).card = List.length x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
x : List α
hx : x ∈ p
⊢ (List.toFinset x).card = List.length x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | intro a h | case h.h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
x : List α
hx : x ∈ p
⊢ ∀ (x_1 : α), x ≠ [x_1] | case h.h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
x : List α
hx : x ∈ p
a : α
h : x = [a]
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
x : List α
hx : x ∈ p
⊢ ∀ (x_1 : α), x ≠ [x_1]
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | apply Nat.not_succ_le_self 1 | case h.h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
x : List α
hx : x ∈ p
a : α
h : x = [a]
⊢ False | case h.h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
x : List α
hx : x ∈ p
a : α
h : x = [a]
⊢ Nat.succ 1 ≤ 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
x : List α
hx : x ∈ p
a : α
h : x = [a]
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | conv_rhs => rw [← List.length_singleton a]; rw [← h] | case h.h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
x : List α
hx : x ∈ p
a : α
h : x = [a]
⊢ Nat.succ 1 ≤ 1 | case h.h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
x : List α
hx : x ∈ p
a : α
h : x = [a]
⊢ Nat.succ 1 ≤ List.length x | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
x : List α
hx : x ∈ p
a : α
h : x = [a]
⊢ Nat.succ 1 ≤ 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | exact hp2 x hx | case h.h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
x : List α
hx : x ∈ p
a : α
h : x = [a]
⊢ Nat.succ 1 ≤ List.length x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
x : List α
hx : x ∈ p
a : α
h : x = [a]
⊢ Nat.succ 1 ≤ List.length x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | intro g | case h.h1
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
⊢ ∀ σ ∈ List.map (fun l => List.formPerm l) p, Perm.IsCycle σ | case h.h1
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
g : Perm α
⊢ g ∈ List.map (fun l => List.formPerm l) p → Perm.IsCycle g | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h1
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
⊢ ∀ σ ∈ List.map (fun l => List.formPerm l) p, Perm.IsCycle σ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/ConjClassCount.lean | Equiv.permWithCycleType_nonempty_iff | [495, 1] | [553, 16] | rw [List.mem_map] | case h.h1
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
g : Perm α
⊢ g ∈ List.map (fun l => List.formPerm l) p → Perm.IsCycle g | case h.h1
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
g : Perm α
⊢ (∃ a ∈ p, List.formPerm a = g) → Perm.IsCycle g | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h1
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
hc : Multiset.sum m ≤ Fintype.card α
h2c : ∀ a ∈ m, 2 ≤ a
hc' : List.sum (Multiset.toList m) ≤ Fintype.card α
p : List (List α)
hp_length : List.map List.length p = Multiset.toList m
hp_nodup : ∀ s ∈ p, List.Nodup s
hp_disj : List.Pairwise List.Disjoint p
hp2 : ∀ x ∈ p, 2 ≤ List.length x
g : Perm α
⊢ g ∈ List.map (fun l => List.formPerm l) p → Perm.IsCycle g
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.