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/MulActionCombination.lean | Nat.combination.mulAction_faithful | [104, 1] | [146, 22] | ext a | G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
h : ∀ (a : α), g • a = a
⊢ toPerm g = 1 | case H
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
h : ∀ (a : α), g • a = a
a : α
⊢ (toPerm g) a = 1 a | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
h : ∀ (a : α), g • a = a
⊢ toPerm g = 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.combination.mulAction_faithful | [104, 1] | [146, 22] | simpa only using h a | case H
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
h : ∀ (a : α), g • a = a
a : α
⊢ (toPerm g) a = 1 a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case H
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
h : ∀ (a : α), g • a = a
a : α
⊢ (toPerm g) a = 1 a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.combination.mulAction_faithful | [104, 1] | [146, 22] | obtain ⟨s, hs, has, has'⟩ := this | G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
this : ∃ s, Set.encard s = ↑n ∧ a ∈ s ∧ g • a ∉ s
⊢ ∃ s, g • s ≠ s | case intro.intro.intro
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
has' : g • a ∉ s
⊢ ∃ s, g • s ≠ s | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
this : ∃ s, Set.encard s = ↑n ∧ a ∈ s ∧ g • a ∉ s
⊢ ∃ s, g • s ≠ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.combination.mulAction_faithful | [104, 1] | [146, 22] | have : Set.Finite s := Set.finite_of_encard_eq_coe hs | case intro.intro.intro
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
has' : g • a ∉ s
⊢ ∃ s, g • s ≠ s | case intro.intro.intro
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
has' : g • a ∉ s
this : Set.Finite s
⊢ ∃ s, g • s ≠ s | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
has' : g • a ∉ s
⊢ ∃ s, g • s ≠ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.combination.mulAction_faithful | [104, 1] | [146, 22] | rw [Set.Finite.encard_eq_coe_toFinset_card this, cast_inj] at hs | case intro.intro.intro
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
has' : g • a ∉ s
this : Set.Finite s
⊢ ∃ s, g • s ≠ s | case intro.intro.intro
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
has : a ∈ s
has' : g • a ∉ s
this : Set.Finite s
hs : (Set.Finite.toFinset this).card = n
⊢ ∃ s, g • s ≠ s | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
has' : g • a ∉ s
this : Set.Finite s
⊢ ∃ s, g • s ≠ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.combination.mulAction_faithful | [104, 1] | [146, 22] | use ⟨Set.Finite.toFinset this, hs⟩ | case intro.intro.intro
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
has : a ∈ s
has' : g • a ∉ s
this : Set.Finite s
hs : (Set.Finite.toFinset this).card = n
⊢ ∃ s, g • s ≠ s | case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
has : a ∈ s
has' : g • a ∉ s
this : Set.Finite s
hs : (Set.Finite.toFinset this).card = n
⊢ g • { val := Set.Finite.toFinset this, property := hs } ≠ { val := Set.Finite.toFinset this, property := hs } | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
has : a ∈ s
has' : g • a ∉ s
this : Set.Finite s
hs : (Set.Finite.toFinset this).card = n
⊢ ∃ s, g • s ≠ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.combination.mulAction_faithful | [104, 1] | [146, 22] | simp only [ne_eq] | case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
has : a ∈ s
has' : g • a ∉ s
this : Set.Finite s
hs : (Set.Finite.toFinset this).card = n
⊢ g • { val := Set.Finite.toFinset this, property := hs } ≠ { val := Set.Finite.toFinset this, property := hs } | case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
has : a ∈ s
has' : g • a ∉ s
this : Set.Finite s
hs : (Set.Finite.toFinset this).card = n
⊢ ¬g • { val := Set.Finite.toFinset this, property := hs } = { val := Set.Finite.toFinset this, property := hs } | Please generate a tactic in lean4 to solve the state.
STATE:
case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
has : a ∈ s
has' : g • a ∉ s
this : Set.Finite s
hs : (Set.Finite.toFinset this).card = n
⊢ g • { val := Set.Finite.toFinset this, property := hs } ≠ { val := Set.Finite.toFinset this, property := hs }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.combination.mulAction_faithful | [104, 1] | [146, 22] | rw [Nat.Combination.eq_iff, ← Finset.coe_inj, combination_mulAction.coe_apply', Finset.coe_smul_finset, Set.Finite.coe_toFinset] | case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
has : a ∈ s
has' : g • a ∉ s
this : Set.Finite s
hs : (Set.Finite.toFinset this).card = n
⊢ ¬g • { val := Set.Finite.toFinset this, property := hs } = { val := Set.Finite.toFinset this, property := hs } | case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
has : a ∈ s
has' : g • a ∉ s
this : Set.Finite s
hs : (Set.Finite.toFinset this).card = n
⊢ ¬g • s = s | Please generate a tactic in lean4 to solve the state.
STATE:
case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
has : a ∈ s
has' : g • a ∉ s
this : Set.Finite s
hs : (Set.Finite.toFinset this).card = n
⊢ ¬g • { val := Set.Finite.toFinset this, property := hs } = { val := Set.Finite.toFinset this, property := hs }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.combination.mulAction_faithful | [104, 1] | [146, 22] | intro h | case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
has : a ∈ s
has' : g • a ∉ s
this : Set.Finite s
hs : (Set.Finite.toFinset this).card = n
⊢ ¬g • s = s | case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
has : a ∈ s
has' : g • a ∉ s
this : Set.Finite s
hs : (Set.Finite.toFinset this).card = n
h : g • s = s
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
has : a ∈ s
has' : g • a ∉ s
this : Set.Finite s
hs : (Set.Finite.toFinset this).card = n
⊢ ¬g • s = s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.combination.mulAction_faithful | [104, 1] | [146, 22] | apply has' | case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
has : a ∈ s
has' : g • a ∉ s
this : Set.Finite s
hs : (Set.Finite.toFinset this).card = n
h : g • s = s
⊢ False | case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
has : a ∈ s
has' : g • a ∉ s
this : Set.Finite s
hs : (Set.Finite.toFinset this).card = n
h : g • s = s
⊢ g • a ∈ s | Please generate a tactic in lean4 to solve the state.
STATE:
case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
has : a ∈ s
has' : g • a ∉ s
this : Set.Finite s
hs : (Set.Finite.toFinset this).card = n
h : g • s = s
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.combination.mulAction_faithful | [104, 1] | [146, 22] | rw [← h] | case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
has : a ∈ s
has' : g • a ∉ s
this : Set.Finite s
hs : (Set.Finite.toFinset this).card = n
h : g • s = s
⊢ g • a ∈ s | case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
has : a ∈ s
has' : g • a ∉ s
this : Set.Finite s
hs : (Set.Finite.toFinset this).card = n
h : g • s = s
⊢ g • a ∈ g • s | Please generate a tactic in lean4 to solve the state.
STATE:
case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
has : a ∈ s
has' : g • a ∉ s
this : Set.Finite s
hs : (Set.Finite.toFinset this).card = n
h : g • s = s
⊢ g • a ∈ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.combination.mulAction_faithful | [104, 1] | [146, 22] | exact Set.smul_mem_smul_set has | case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
has : a ∈ s
has' : g • a ∉ s
this : Set.Finite s
hs : (Set.Finite.toFinset this).card = n
h : g • s = s
⊢ g • a ∈ g • s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
s : Set α
has : a ∈ s
has' : g • a ∉ s
this : Set.Finite s
hs : (Set.Finite.toFinset this).card = n
h : g • s = s
⊢ g • a ∈ g • s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.combination.mulAction_faithful | [104, 1] | [146, 22] | simp only [Set.subset_compl_singleton_iff, Set.mem_singleton_iff] | G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
⊢ {a} ⊆ {g • a}ᶜ | G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
⊢ ¬g • a = a | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
⊢ {a} ⊆ {g • a}ᶜ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.combination.mulAction_faithful | [104, 1] | [146, 22] | exact ha | G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
⊢ ¬g • a = a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
⊢ ¬g • a = a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.combination.mulAction_faithful | [104, 1] | [146, 22] | rw [← not_lt, ← WithTop.add_one_lt_coe_succ_iff, not_lt, add_comm,
← Set.encard_singleton (g • a), Set.encard_add_encard_compl, Set.encard_univ] | G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
this : {a} ⊆ {g • a}ᶜ
⊢ ↑n ≤ Set.encard {g • a}ᶜ | G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
this : {a} ⊆ {g • a}ᶜ
⊢ ↑(succ n) ≤ PartENat.withTopEquiv (PartENat.card α) | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
this : {a} ⊆ {g • a}ᶜ
⊢ ↑n ≤ Set.encard {g • a}ᶜ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.combination.mulAction_faithful | [104, 1] | [146, 22] | rw [← PartENat.withTopEquiv_natCast, PartENat.withTopEquiv_le] | G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
this : {a} ⊆ {g • a}ᶜ
⊢ ↑(succ n) ≤ PartENat.withTopEquiv (PartENat.card α) | G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
this : {a} ⊆ {g • a}ᶜ
⊢ ↑(succ n) ≤ PartENat.card α | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
this : {a} ⊆ {g • a}ᶜ
⊢ ↑(succ n) ≤ PartENat.withTopEquiv (PartENat.card α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.combination.mulAction_faithful | [104, 1] | [146, 22] | exact hα | G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
this : {a} ⊆ {g • a}ᶜ
⊢ ↑(succ n) ≤ PartENat.card α | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
this : {a} ⊆ {g • a}ᶜ
⊢ ↑(succ n) ≤ PartENat.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.combination.mulAction_faithful | [104, 1] | [146, 22] | rw [Set.encard_singleton, ← Nat.cast_one, Nat.cast_le] | G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
this : {a} ⊆ {g • a}ᶜ
hα' : ↑n ≤ Set.encard {g • a}ᶜ
⊢ Set.encard {a} ≤ ↑n | G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
this : {a} ⊆ {g • a}ᶜ
hα' : ↑n ≤ Set.encard {g • a}ᶜ
⊢ 1 ≤ n | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
this : {a} ⊆ {g • a}ᶜ
hα' : ↑n ≤ Set.encard {g • a}ᶜ
⊢ Set.encard {a} ≤ ↑n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.combination.mulAction_faithful | [104, 1] | [146, 22] | exact hn | G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
this : {a} ⊆ {g • a}ᶜ
hα' : ↑n ≤ Set.encard {g • a}ᶜ
⊢ 1 ≤ n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
this : {a} ⊆ {g • a}ᶜ
hα' : ↑n ≤ Set.encard {g • a}ᶜ
⊢ 1 ≤ n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.combination.mulAction_faithful | [104, 1] | [146, 22] | exact hs | case h.left
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
this : {a} ⊆ {g • a}ᶜ
hα' : ↑n ≤ Set.encard {g • a}ᶜ
s : Set α
has : {a} ⊆ s
has' : s ⊆ {g • a}ᶜ
hs : Set.encard s = ↑n
⊢ Set.encard s = ↑n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
this : {a} ⊆ {g • a}ᶜ
hα' : ↑n ≤ Set.encard {g • a}ᶜ
s : Set α
has : {a} ⊆ s
has' : s ⊆ {g • a}ᶜ
hs : Set.encard s = ↑n
⊢ Set.encard s = ↑n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.combination.mulAction_faithful | [104, 1] | [146, 22] | simp only [Set.singleton_subset_iff, Set.subset_compl_singleton_iff] at has has' | case h.right
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
this : {a} ⊆ {g • a}ᶜ
hα' : ↑n ≤ Set.encard {g • a}ᶜ
s : Set α
has : {a} ⊆ s
has' : s ⊆ {g • a}ᶜ
hs : Set.encard s = ↑n
⊢ a ∈ s ∧ g • a ∉ s | case h.right
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
this : {a} ⊆ {g • a}ᶜ
hα' : ↑n ≤ Set.encard {g • a}ᶜ
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
has' : g • a ∉ s
⊢ a ∈ s ∧ g • a ∉ s | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
this : {a} ⊆ {g • a}ᶜ
hα' : ↑n ≤ Set.encard {g • a}ᶜ
s : Set α
has : {a} ⊆ s
has' : s ⊆ {g • a}ᶜ
hs : Set.encard s = ↑n
⊢ a ∈ s ∧ g • a ∉ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.combination.mulAction_faithful | [104, 1] | [146, 22] | exact ⟨has, has'⟩ | case h.right
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
this : {a} ⊆ {g • a}ᶜ
hα' : ↑n ≤ Set.encard {g • a}ᶜ
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
has' : g • a ∉ s
⊢ a ∈ s ∧ g • a ∉ s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
hn : 1 ≤ n
hα : ↑(succ n) ≤ PartENat.card α
g : G
hg : toPerm g ≠ 1
a : α
ha : g • a ≠ a
this : {a} ⊆ {g • a}ᶜ
hα' : ↑n ≤ Set.encard {g • a}ᶜ
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
has' : g • a ∉ s
⊢ a ∈ s ∧ g • a ∉ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Finset.exists_fin_enum | [180, 1] | [188, 6] | have slc : s.toList.length = n := by rw [← hsn, Finset.length_toList] | G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hsn : s.card = n
⊢ ∃ f, map f univ = s | G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hsn : s.card = n
slc : List.length (toList s) = n
⊢ ∃ f, map f univ = s | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hsn : s.card = n
⊢ ∃ f, map f univ = s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Finset.exists_fin_enum | [180, 1] | [188, 6] | use ⟨s.toList.get, by rw [← List.nodup_iff_injective_get]; exact Finset.nodup_toList s⟩ | G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hsn : s.card = n
slc : List.length (toList s) = n
⊢ ∃ f, map f univ = s | case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hsn : s.card = n
slc : List.length (toList s) = n
⊢ map { toFun := List.get (toList s), inj' := ⋯ } univ = s | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hsn : s.card = n
slc : List.length (toList s) = n
⊢ ∃ f, map f univ = s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Finset.exists_fin_enum | [180, 1] | [188, 6] | ext a | case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hsn : s.card = n
slc : List.length (toList s) = n
⊢ map { toFun := List.get (toList s), inj' := ⋯ } univ = s | case h.a
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hsn : s.card = n
slc : List.length (toList s) = n
a : α
⊢ a ∈ map { toFun := List.get (toList s), inj' := ⋯ } univ ↔ a ∈ s | Please generate a tactic in lean4 to solve the state.
STATE:
case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hsn : s.card = n
slc : List.length (toList s) = n
⊢ map { toFun := List.get (toList s), inj' := ⋯ } univ = s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Finset.exists_fin_enum | [180, 1] | [188, 6] | simp only [Finset.mem_map, Finset.mem_univ, true_and] | case h.a
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hsn : s.card = n
slc : List.length (toList s) = n
a : α
⊢ a ∈ map { toFun := List.get (toList s), inj' := ⋯ } univ ↔ a ∈ s | case h.a
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hsn : s.card = n
slc : List.length (toList s) = n
a : α
⊢ (∃ a_1, { toFun := List.get (toList s), inj' := ⋯ } a_1 = a) ↔ a ∈ s | Please generate a tactic in lean4 to solve the state.
STATE:
case h.a
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hsn : s.card = n
slc : List.length (toList s) = n
a : α
⊢ a ∈ map { toFun := List.get (toList s), inj' := ⋯ } univ ↔ a ∈ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Finset.exists_fin_enum | [180, 1] | [188, 6] | rw [← Finset.mem_toList, List.mem_iff_get] | case h.a
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hsn : s.card = n
slc : List.length (toList s) = n
a : α
⊢ (∃ a_1, { toFun := List.get (toList s), inj' := ⋯ } a_1 = a) ↔ a ∈ s | case h.a
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hsn : s.card = n
slc : List.length (toList s) = n
a : α
⊢ (∃ a_1, { toFun := List.get (toList s), inj' := ⋯ } a_1 = a) ↔ ∃ n, List.get (toList s) n = a | Please generate a tactic in lean4 to solve the state.
STATE:
case h.a
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hsn : s.card = n
slc : List.length (toList s) = n
a : α
⊢ (∃ a_1, { toFun := List.get (toList s), inj' := ⋯ } a_1 = a) ↔ a ∈ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Finset.exists_fin_enum | [180, 1] | [188, 6] | rfl | case h.a
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hsn : s.card = n
slc : List.length (toList s) = n
a : α
⊢ (∃ a_1, { toFun := List.get (toList s), inj' := ⋯ } a_1 = a) ↔ ∃ n, List.get (toList s) n = a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.a
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hsn : s.card = n
slc : List.length (toList s) = n
a : α
⊢ (∃ a_1, { toFun := List.get (toList s), inj' := ⋯ } a_1 = a) ↔ ∃ n, List.get (toList s) n = a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Finset.exists_fin_enum | [180, 1] | [188, 6] | rw [← hsn, Finset.length_toList] | G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hsn : s.card = n
⊢ List.length (toList s) = n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hsn : s.card = n
⊢ List.length (toList s) = n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Finset.exists_fin_enum | [180, 1] | [188, 6] | rw [← List.nodup_iff_injective_get] | G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hsn : s.card = n
slc : List.length (toList s) = n
⊢ Function.Injective (List.get (toList s)) | G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hsn : s.card = n
slc : List.length (toList s) = n
⊢ List.Nodup (toList s) | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hsn : s.card = n
slc : List.length (toList s) = n
⊢ Function.Injective (List.get (toList s))
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Finset.exists_fin_enum | [180, 1] | [188, 6] | exact Finset.nodup_toList s | G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hsn : s.card = n
slc : List.length (toList s) = n
⊢ List.Nodup (toList s) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hsn : s.card = n
slc : List.length (toList s) = n
⊢ List.Nodup (toList s)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | EmbeddingToFinset.map_surjective | [190, 1] | [198, 11] | rintro ⟨s, hs⟩ | G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
⊢ Function.Surjective ⇑(map G α n) | case mk
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hs : s ∈ Nat.Combination α n
⊢ ∃ a, (map G α n) a = { val := s, property := hs } | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
⊢ Function.Surjective ⇑(map G α n)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | EmbeddingToFinset.map_surjective | [190, 1] | [198, 11] | rw [Nat.Combination.mem_iff] at hs | case mk
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hs : s ∈ Nat.Combination α n
⊢ ∃ a, (map G α n) a = { val := s, property := hs } | case mk
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hs✝ : s ∈ Nat.Combination α n
hs : s.card = n
⊢ ∃ a, (map G α n) a = { val := s, property := hs✝ } | Please generate a tactic in lean4 to solve the state.
STATE:
case mk
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hs : s ∈ Nat.Combination α n
⊢ ∃ a, (map G α n) a = { val := s, property := hs }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | EmbeddingToFinset.map_surjective | [190, 1] | [198, 11] | obtain ⟨f, hf⟩ := s.exists_fin_enum α hs | case mk
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hs✝ : s ∈ Nat.Combination α n
hs : s.card = n
⊢ ∃ a, (map G α n) a = { val := s, property := hs✝ } | case mk.intro
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hs✝ : s ∈ Nat.Combination α n
hs : s.card = n
f : Fin n ↪ α
hf : Finset.map f Finset.univ = s
⊢ ∃ a, (map G α n) a = { val := s, property := hs✝ } | Please generate a tactic in lean4 to solve the state.
STATE:
case mk
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hs✝ : s ∈ Nat.Combination α n
hs : s.card = n
⊢ ∃ a, (map G α n) a = { val := s, property := hs✝ }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | EmbeddingToFinset.map_surjective | [190, 1] | [198, 11] | use { toFun := f, inj' := f.injective } | case mk.intro
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hs✝ : s ∈ Nat.Combination α n
hs : s.card = n
f : Fin n ↪ α
hf : Finset.map f Finset.univ = s
⊢ ∃ a, (map G α n) a = { val := s, property := hs✝ } | case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hs✝ : s ∈ Nat.Combination α n
hs : s.card = n
f : Fin n ↪ α
hf : Finset.map f Finset.univ = s
⊢ (map G α n) { toFun := ⇑f, inj' := ⋯ } = { val := s, property := hs✝ } | Please generate a tactic in lean4 to solve the state.
STATE:
case mk.intro
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hs✝ : s ∈ Nat.Combination α n
hs : s.card = n
f : Fin n ↪ α
hf : Finset.map f Finset.univ = s
⊢ ∃ a, (map G α n) a = { val := s, property := hs✝ }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | EmbeddingToFinset.map_surjective | [190, 1] | [198, 11] | simp only [Function.Embedding.mk_coe, Nat.Combination.eq_iff] | case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hs✝ : s ∈ Nat.Combination α n
hs : s.card = n
f : Fin n ↪ α
hf : Finset.map f Finset.univ = s
⊢ (map G α n) { toFun := ⇑f, inj' := ⋯ } = { val := s, property := hs✝ } | case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hs✝ : s ∈ Nat.Combination α n
hs : s.card = n
f : Fin n ↪ α
hf : Finset.map f Finset.univ = s
⊢ ↑((map G α n) f) = s | Please generate a tactic in lean4 to solve the state.
STATE:
case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hs✝ : s ∈ Nat.Combination α n
hs : s.card = n
f : Fin n ↪ α
hf : Finset.map f Finset.univ = s
⊢ (map G α n) { toFun := ⇑f, inj' := ⋯ } = { val := s, property := hs✝ }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | EmbeddingToFinset.map_surjective | [190, 1] | [198, 11] | exact hf | case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hs✝ : s ∈ Nat.Combination α n
hs : s.card = n
f : Fin n ↪ α
hf : Finset.map f Finset.univ = s
⊢ ↑((map G α n) f) = s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
G : Type u_1
inst✝² : Group G
α : Type u_2
inst✝¹ : DecidableEq α
inst✝ : MulAction G α
n : ℕ
s : Finset α
hs✝ : s ∈ Nat.Combination α n
hs : s.card = n
f : Fin n ↪ α
hf : Finset.map f Finset.univ = s
⊢ ↑((map G α n) f) = s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | suffices Nonempty (n.Combination α) by
obtain ⟨s, hs⟩ := this
change s.card = n at hs
let h'1 := id h1
rw [← hs, Finset.card_pos] at h'1 ; obtain ⟨a, ha⟩ := h'1
let h'2 := id h2
rw [← hs, Finset.card_lt_iff_ne_univ, Ne.def, ← Finset.coe_eq_univ, ← Ne.def,
Set.ne_univ_iff_exists_not_mem] at h'2
obtain ⟨b, hb⟩ := h'2
let t : Finset α := insert b (Finset.erase s a)
rw [nontrivial_iff]
use ⟨s, hs⟩
use ⟨t, by
rw [Nat.Combination.mem_iff]
rw [Finset.card_insert_of_not_mem]
rw [Finset.card_erase_of_mem ha]
rw [hs]; rw [Nat.sub_add_cancel]; exact h1
intro h; apply hb; apply Finset.erase_subset; exact h⟩
intro h
rw [Subtype.mk_eq_mk] at h
apply hb
rw [h]
exact Finset.mem_insert_self b _ | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
⊢ Nontrivial ↑(Combination α n) | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
⊢ Nonempty ↑(Combination α n) | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
⊢ Nontrivial ↑(Combination α n)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | obtain ⟨s, _, hs'⟩ := Finset.exists_smaller_set (Finset.univ : Finset α) n
(le_of_lt h2) | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
⊢ Nonempty ↑(Combination α n) | case intro.intro
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
left✝ : s ⊆ Finset.univ
hs' : s.card = n
⊢ Nonempty ↑(Combination α n) | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
⊢ Nonempty ↑(Combination α n)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | use s | case intro.intro
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
left✝ : s ⊆ Finset.univ
hs' : s.card = n
⊢ Nonempty ↑(Combination α n) | case property
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
left✝ : s ⊆ Finset.univ
hs' : s.card = n
⊢ s ∈ Combination α n | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
left✝ : s ⊆ Finset.univ
hs' : s.card = n
⊢ Nonempty ↑(Combination α n)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | exact hs' | case property
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
left✝ : s ⊆ Finset.univ
hs' : s.card = n
⊢ s ∈ Combination α n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case property
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
left✝ : s ⊆ Finset.univ
hs' : s.card = n
⊢ s ∈ Combination α n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | obtain ⟨s, hs⟩ := this | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
this : Nonempty ↑(Combination α n)
⊢ Nontrivial ↑(Combination α n) | case intro.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s ∈ Combination α n
⊢ Nontrivial ↑(Combination α n) | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
this : Nonempty ↑(Combination α n)
⊢ Nontrivial ↑(Combination α n)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | change s.card = n at hs | case intro.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s ∈ Combination α n
⊢ Nontrivial ↑(Combination α n) | case intro.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
⊢ Nontrivial ↑(Combination α n) | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s ∈ Combination α n
⊢ Nontrivial ↑(Combination α n)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | let h'1 := id h1 | case intro.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
⊢ Nontrivial ↑(Combination α n) | case intro.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
h'1 : 0 < n := id h1
⊢ Nontrivial ↑(Combination α n) | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
⊢ Nontrivial ↑(Combination α n)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | rw [← hs, Finset.card_pos] at h'1 | case intro.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
h'1 : 0 < n := id h1
⊢ Nontrivial ↑(Combination α n) | case intro.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
h'1 : s.Nonempty
⊢ Nontrivial ↑(Combination α n) | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
h'1 : 0 < n := id h1
⊢ Nontrivial ↑(Combination α n)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | obtain ⟨a, ha⟩ := h'1 | case intro.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
h'1 : s.Nonempty
⊢ Nontrivial ↑(Combination α n) | case intro.mk.intro
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
⊢ Nontrivial ↑(Combination α n) | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
h'1 : s.Nonempty
⊢ Nontrivial ↑(Combination α n)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | let h'2 := id h2 | case intro.mk.intro
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
⊢ Nontrivial ↑(Combination α n) | case intro.mk.intro
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
h'2 : n < Fintype.card α := id h2
⊢ Nontrivial ↑(Combination α n) | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.mk.intro
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
⊢ Nontrivial ↑(Combination α n)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | rw [← hs, Finset.card_lt_iff_ne_univ, Ne.def, ← Finset.coe_eq_univ, ← Ne.def,
Set.ne_univ_iff_exists_not_mem] at h'2 | case intro.mk.intro
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
h'2 : n < Fintype.card α := id h2
⊢ Nontrivial ↑(Combination α n) | case intro.mk.intro
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
h'2 : ∃ a, a ∉ ↑s
⊢ Nontrivial ↑(Combination α n) | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.mk.intro
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
h'2 : n < Fintype.card α := id h2
⊢ Nontrivial ↑(Combination α n)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | obtain ⟨b, hb⟩ := h'2 | case intro.mk.intro
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
h'2 : ∃ a, a ∉ ↑s
⊢ Nontrivial ↑(Combination α n) | case intro.mk.intro.intro
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
⊢ Nontrivial ↑(Combination α n) | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.mk.intro
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
h'2 : ∃ a, a ∉ ↑s
⊢ Nontrivial ↑(Combination α n)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | let t : Finset α := insert b (Finset.erase s a) | case intro.mk.intro.intro
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
⊢ Nontrivial ↑(Combination α n) | case intro.mk.intro.intro
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ Nontrivial ↑(Combination α n) | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.mk.intro.intro
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
⊢ Nontrivial ↑(Combination α n)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | rw [nontrivial_iff] | case intro.mk.intro.intro
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ Nontrivial ↑(Combination α n) | case intro.mk.intro.intro
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ ∃ x y, x ≠ y | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.mk.intro.intro
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ Nontrivial ↑(Combination α n)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | use ⟨s, hs⟩ | case intro.mk.intro.intro
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ ∃ x y, x ≠ y | case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ ∃ y, { val := s, property := hs } ≠ y | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.mk.intro.intro
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ ∃ x y, x ≠ y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | use ⟨t, by
rw [Nat.Combination.mem_iff]
rw [Finset.card_insert_of_not_mem]
rw [Finset.card_erase_of_mem ha]
rw [hs]; rw [Nat.sub_add_cancel]; exact h1
intro h; apply hb; apply Finset.erase_subset; exact h⟩ | case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ ∃ y, { val := s, property := hs } ≠ y | case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ { val := s, property := hs } ≠ { val := t, property := ⋯ } | Please generate a tactic in lean4 to solve the state.
STATE:
case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ ∃ y, { val := s, property := hs } ≠ y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | intro h | case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ { val := s, property := hs } ≠ { val := t, property := ⋯ } | case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
h : { val := s, property := hs } = { val := t, property := ⋯ }
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ { val := s, property := hs } ≠ { val := t, property := ⋯ }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | rw [Subtype.mk_eq_mk] at h | case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
h : { val := s, property := hs } = { val := t, property := ⋯ }
⊢ False | case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
h : s = t
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
h : { val := s, property := hs } = { val := t, property := ⋯ }
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | apply hb | case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
h : s = t
⊢ False | case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
h : s = t
⊢ b ∈ ↑s | Please generate a tactic in lean4 to solve the state.
STATE:
case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
h : s = t
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | rw [h] | case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
h : s = t
⊢ b ∈ ↑s | case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
h : s = t
⊢ b ∈ ↑t | Please generate a tactic in lean4 to solve the state.
STATE:
case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
h : s = t
⊢ b ∈ ↑s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | exact Finset.mem_insert_self b _ | case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
h : s = t
⊢ b ∈ ↑t | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
h : s = t
⊢ b ∈ ↑t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | rw [Nat.Combination.mem_iff] | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ t ∈ Combination α n | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ t.card = n | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ t ∈ Combination α n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | rw [Finset.card_insert_of_not_mem] | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ t.card = n | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ (Finset.erase s a).card + 1 = n
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ b ∉ Finset.erase s a | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ t.card = n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | rw [Finset.card_erase_of_mem ha] | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ (Finset.erase s a).card + 1 = n
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ b ∉ Finset.erase s a | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ s.card - 1 + 1 = n
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ b ∉ Finset.erase s a | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ (Finset.erase s a).card + 1 = n
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ b ∉ Finset.erase s a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | rw [hs] | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ s.card - 1 + 1 = n
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ b ∉ Finset.erase s a | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ n - 1 + 1 = n
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ b ∉ Finset.erase s a | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ s.card - 1 + 1 = n
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ b ∉ Finset.erase s a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | rw [Nat.sub_add_cancel] | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ n - 1 + 1 = n
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ b ∉ Finset.erase s a | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ 1 ≤ n
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ b ∉ Finset.erase s a | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ n - 1 + 1 = n
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ b ∉ Finset.erase s a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | exact h1 | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ 1 ≤ n
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ b ∉ Finset.erase s a | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ b ∉ Finset.erase s a | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ 1 ≤ n
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ b ∉ Finset.erase s a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | intro h | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ b ∉ Finset.erase s a | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
h : b ∈ Finset.erase s a
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
⊢ b ∉ Finset.erase s a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | apply hb | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
h : b ∈ Finset.erase s a
⊢ False | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
h : b ∈ Finset.erase s a
⊢ b ∈ ↑s | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
h : b ∈ Finset.erase s a
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | apply Finset.erase_subset | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
h : b ∈ Finset.erase s a
⊢ b ∈ ↑s | case a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
h : b ∈ Finset.erase s a
⊢ b ∈ Finset.erase s ?a
case a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
h : b ∈ Finset.erase s a
⊢ α | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
h : b ∈ Finset.erase s a
⊢ b ∈ ↑s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_nontrivial | [203, 1] | [232, 12] | exact h | case a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
h : b ∈ Finset.erase s a
⊢ b ∈ Finset.erase s ?a
case a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
h : b ∈ Finset.erase s a
⊢ α | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
h : b ∈ Finset.erase s a
⊢ b ∈ Finset.erase s ?a
case a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
h1 : 0 < n
h2 : n < Fintype.card α
s : Finset α
hs : s.card = n
a : α
ha : a ∈ s
b : α
hb : b ∉ ↑s
t : Finset α := insert b (Finset.erase s a)
h : b ∈ Finset.erase s a
⊢ α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_isPretransitive | [241, 1] | [244, 43] | apply Nat.Combination_isPretransitive_of_IsMultiplyPretransitive | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
⊢ IsPretransitive (Equiv.Perm α) ↑(Combination α n) | case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
⊢ IsMultiplyPretransitive (Equiv.Perm α) α n | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
⊢ IsPretransitive (Equiv.Perm α) ↑(Combination α n)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_isPretransitive | [241, 1] | [244, 43] | apply Equiv.Perm.isMultiplyPretransitive | case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
⊢ IsMultiplyPretransitive (Equiv.Perm α) α n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
⊢ IsMultiplyPretransitive (Equiv.Perm α) α n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_compl_bijective | [264, 1] | [277, 37] | constructor | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
⊢ Function.Bijective ⇑(Combination_compl G α hm) | case left
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
⊢ Function.Injective ⇑(Combination_compl G α hm)
case right
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
⊢ Function.Surjective ⇑(Combination_compl G α hm) | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
⊢ Function.Bijective ⇑(Combination_compl G α hm)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_compl_bijective | [264, 1] | [277, 37] | rintro ⟨s, hs⟩ ⟨t, ht⟩ h | case left
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
⊢ Function.Injective ⇑(Combination_compl G α hm) | case left.mk.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α n
t : Finset α
ht : t ∈ Combination α n
h : (Combination_compl G α hm) { val := s, property := hs } = (Combination_compl G α hm) { val := t, property := ht }
⊢ { val := s, property := hs } = { val := t, property := ht } | Please generate a tactic in lean4 to solve the state.
STATE:
case left
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
⊢ Function.Injective ⇑(Combination_compl G α hm)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_compl_bijective | [264, 1] | [277, 37] | rw [← Subtype.coe_inj] at h | case left.mk.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α n
t : Finset α
ht : t ∈ Combination α n
h : (Combination_compl G α hm) { val := s, property := hs } = (Combination_compl G α hm) { val := t, property := ht }
⊢ { val := s, property := hs } = { val := t, property := ht } | case left.mk.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α n
t : Finset α
ht : t ∈ Combination α n
h :
↑((Combination_compl G α hm) { val := s, property := hs }) =
↑((Combination_compl G α hm) { val := t, property := ht })
⊢ { val := s, property := hs } = { val := t, property := ht } | Please generate a tactic in lean4 to solve the state.
STATE:
case left.mk.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α n
t : Finset α
ht : t ∈ Combination α n
h : (Combination_compl G α hm) { val := s, property := hs } = (Combination_compl G α hm) { val := t, property := ht }
⊢ { val := s, property := hs } = { val := t, property := ht }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_compl_bijective | [264, 1] | [277, 37] | change sᶜ = tᶜ at h | case left.mk.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α n
t : Finset α
ht : t ∈ Combination α n
h :
↑((Combination_compl G α hm) { val := s, property := hs }) =
↑((Combination_compl G α hm) { val := t, property := ht })
⊢ { val := s, property := hs } = { val := t, property := ht } | case left.mk.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α n
t : Finset α
ht : t ∈ Combination α n
h : sᶜ = tᶜ
⊢ { val := s, property := hs } = { val := t, property := ht } | Please generate a tactic in lean4 to solve the state.
STATE:
case left.mk.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α n
t : Finset α
ht : t ∈ Combination α n
h :
↑((Combination_compl G α hm) { val := s, property := hs }) =
↑((Combination_compl G α hm) { val := t, property := ht })
⊢ { val := s, property := hs } = { val := t, property := ht }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_compl_bijective | [264, 1] | [277, 37] | apply Subtype.coe_injective | case left.mk.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α n
t : Finset α
ht : t ∈ Combination α n
h : sᶜ = tᶜ
⊢ { val := s, property := hs } = { val := t, property := ht } | case left.mk.mk.a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α n
t : Finset α
ht : t ∈ Combination α n
h : sᶜ = tᶜ
⊢ (fun a => ↑a) { val := s, property := hs } = (fun a => ↑a) { val := t, property := ht } | Please generate a tactic in lean4 to solve the state.
STATE:
case left.mk.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α n
t : Finset α
ht : t ∈ Combination α n
h : sᶜ = tᶜ
⊢ { val := s, property := hs } = { val := t, property := ht }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_compl_bijective | [264, 1] | [277, 37] | change s = t | case left.mk.mk.a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α n
t : Finset α
ht : t ∈ Combination α n
h : sᶜ = tᶜ
⊢ (fun a => ↑a) { val := s, property := hs } = (fun a => ↑a) { val := t, property := ht } | case left.mk.mk.a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α n
t : Finset α
ht : t ∈ Combination α n
h : sᶜ = tᶜ
⊢ s = t | Please generate a tactic in lean4 to solve the state.
STATE:
case left.mk.mk.a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α n
t : Finset α
ht : t ∈ Combination α n
h : sᶜ = tᶜ
⊢ (fun a => ↑a) { val := s, property := hs } = (fun a => ↑a) { val := t, property := ht }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_compl_bijective | [264, 1] | [277, 37] | rw [← compl_compl s] | case left.mk.mk.a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α n
t : Finset α
ht : t ∈ Combination α n
h : sᶜ = tᶜ
⊢ s = t | case left.mk.mk.a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α n
t : Finset α
ht : t ∈ Combination α n
h : sᶜ = tᶜ
⊢ sᶜᶜ = t | Please generate a tactic in lean4 to solve the state.
STATE:
case left.mk.mk.a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α n
t : Finset α
ht : t ∈ Combination α n
h : sᶜ = tᶜ
⊢ s = t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_compl_bijective | [264, 1] | [277, 37] | rw [h] | case left.mk.mk.a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α n
t : Finset α
ht : t ∈ Combination α n
h : sᶜ = tᶜ
⊢ sᶜᶜ = t | case left.mk.mk.a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α n
t : Finset α
ht : t ∈ Combination α n
h : sᶜ = tᶜ
⊢ tᶜᶜ = t | Please generate a tactic in lean4 to solve the state.
STATE:
case left.mk.mk.a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α n
t : Finset α
ht : t ∈ Combination α n
h : sᶜ = tᶜ
⊢ sᶜᶜ = t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_compl_bijective | [264, 1] | [277, 37] | rw [compl_compl] | case left.mk.mk.a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α n
t : Finset α
ht : t ∈ Combination α n
h : sᶜ = tᶜ
⊢ tᶜᶜ = t | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case left.mk.mk.a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α n
t : Finset α
ht : t ∈ Combination α n
h : sᶜ = tᶜ
⊢ tᶜᶜ = t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_compl_bijective | [264, 1] | [277, 37] | rintro ⟨s, hs⟩ | case right
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
⊢ Function.Surjective ⇑(Combination_compl G α hm) | case right.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α m
⊢ ∃ a, (Combination_compl G α hm) a = { val := s, property := hs } | Please generate a tactic in lean4 to solve the state.
STATE:
case right
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
⊢ Function.Surjective ⇑(Combination_compl G α hm)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_compl_bijective | [264, 1] | [277, 37] | have hn : n + m = Fintype.card α := by rw [add_comm]; exact hm | case right.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α m
⊢ ∃ a, (Combination_compl G α hm) a = { val := s, property := hs } | case right.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α m
hn : n + m = Fintype.card α
⊢ ∃ a, (Combination_compl G α hm) a = { val := s, property := hs } | Please generate a tactic in lean4 to solve the state.
STATE:
case right.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α m
⊢ ∃ a, (Combination_compl G α hm) a = { val := s, property := hs }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_compl_bijective | [264, 1] | [277, 37] | use Nat.Combination_compl G α hn ⟨s, hs⟩ | case right.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α m
hn : n + m = Fintype.card α
⊢ ∃ a, (Combination_compl G α hm) a = { val := s, property := hs } | case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α m
hn : n + m = Fintype.card α
⊢ (Combination_compl G α hm) ((Combination_compl G α hn) { val := s, property := hs }) = { val := s, property := hs } | Please generate a tactic in lean4 to solve the state.
STATE:
case right.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α m
hn : n + m = Fintype.card α
⊢ ∃ a, (Combination_compl G α hm) a = { val := s, property := hs }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_compl_bijective | [264, 1] | [277, 37] | apply Subtype.coe_injective | case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α m
hn : n + m = Fintype.card α
⊢ (Combination_compl G α hm) ((Combination_compl G α hn) { val := s, property := hs }) = { val := s, property := hs } | case h.a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α m
hn : n + m = Fintype.card α
⊢ (fun a => ↑a) ((Combination_compl G α hm) ((Combination_compl G α hn) { val := s, property := hs })) =
(fun a => ↑a) { val := s, property := hs } | Please generate a tactic in lean4 to solve the state.
STATE:
case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α m
hn : n + m = Fintype.card α
⊢ (Combination_compl G α hm) ((Combination_compl G α hn) { val := s, property := hs }) = { val := s, property := hs }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_compl_bijective | [264, 1] | [277, 37] | change sᶜᶜ = s | case h.a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α m
hn : n + m = Fintype.card α
⊢ (fun a => ↑a) ((Combination_compl G α hm) ((Combination_compl G α hn) { val := s, property := hs })) =
(fun a => ↑a) { val := s, property := hs } | case h.a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α m
hn : n + m = Fintype.card α
⊢ sᶜᶜ = s | Please generate a tactic in lean4 to solve the state.
STATE:
case h.a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α m
hn : n + m = Fintype.card α
⊢ (fun a => ↑a) ((Combination_compl G α hm) ((Combination_compl G α hn) { val := s, property := hs })) =
(fun a => ↑a) { val := s, property := hs }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_compl_bijective | [264, 1] | [277, 37] | rw [compl_compl] | case h.a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α m
hn : n + m = Fintype.card α
⊢ sᶜᶜ = s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α m
hn : n + m = Fintype.card α
⊢ sᶜᶜ = s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_compl_bijective | [264, 1] | [277, 37] | rw [add_comm] | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α m
⊢ n + m = Fintype.card α | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α m
⊢ m + n = Fintype.card α | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α m
⊢ n + m = Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.Combination_compl_bijective | [264, 1] | [277, 37] | exact hm | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α m
⊢ m + n = Fintype.card α | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
m : ℕ
hm : m + n = Fintype.card α
s : Finset α
hs : s ∈ Combination α m
⊢ m + n = Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.bijective_toCombination_one_equivariant | [286, 1] | [298, 8] | constructor | G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
⊢ Function.Bijective ⇑(toCombination_one_equivariant G α) | case left
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
⊢ Function.Injective ⇑(toCombination_one_equivariant G α)
case right
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
⊢ Function.Surjective ⇑(toCombination_one_equivariant G α) | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
⊢ Function.Bijective ⇑(toCombination_one_equivariant G α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.bijective_toCombination_one_equivariant | [286, 1] | [298, 8] | intro a b h | case left
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
⊢ Function.Injective ⇑(toCombination_one_equivariant G α) | case left
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
a b : α
h : (toCombination_one_equivariant G α) a = (toCombination_one_equivariant G α) b
⊢ a = b | Please generate a tactic in lean4 to solve the state.
STATE:
case left
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
⊢ Function.Injective ⇑(toCombination_one_equivariant G α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.bijective_toCombination_one_equivariant | [286, 1] | [298, 8] | simp only [toCombination_one_equivariant, Combination.eq_iff] at h | case left
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
a b : α
h : (toCombination_one_equivariant G α) a = (toCombination_one_equivariant G α) b
⊢ a = b | case left
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
a b : α
h :
↑({ toFun := fun x => { val := {x}, property := ⋯ }, map_smul' := ⋯ } a) =
↑({ toFun := fun x => { val := {x}, property := ⋯ }, map_smul' := ⋯ } b)
⊢ a = b | Please generate a tactic in lean4 to solve the state.
STATE:
case left
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
a b : α
h : (toCombination_one_equivariant G α) a = (toCombination_one_equivariant G α) b
⊢ a = b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.bijective_toCombination_one_equivariant | [286, 1] | [298, 8] | apply Finset.singleton_injective | case left
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
a b : α
h :
↑({ toFun := fun x => { val := {x}, property := ⋯ }, map_smul' := ⋯ } a) =
↑({ toFun := fun x => { val := {x}, property := ⋯ }, map_smul' := ⋯ } b)
⊢ a = b | case left.a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
a b : α
h :
↑({ toFun := fun x => { val := {x}, property := ⋯ }, map_smul' := ⋯ } a) =
↑({ toFun := fun x => { val := {x}, property := ⋯ }, map_smul' := ⋯ } b)
⊢ {a} = {b} | Please generate a tactic in lean4 to solve the state.
STATE:
case left
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
a b : α
h :
↑({ toFun := fun x => { val := {x}, property := ⋯ }, map_smul' := ⋯ } a) =
↑({ toFun := fun x => { val := {x}, property := ⋯ }, map_smul' := ⋯ } b)
⊢ a = b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.bijective_toCombination_one_equivariant | [286, 1] | [298, 8] | exact h | case left.a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
a b : α
h :
↑({ toFun := fun x => { val := {x}, property := ⋯ }, map_smul' := ⋯ } a) =
↑({ toFun := fun x => { val := {x}, property := ⋯ }, map_smul' := ⋯ } b)
⊢ {a} = {b} | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case left.a
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
a b : α
h :
↑({ toFun := fun x => { val := {x}, property := ⋯ }, map_smul' := ⋯ } a) =
↑({ toFun := fun x => { val := {x}, property := ⋯ }, map_smul' := ⋯ } b)
⊢ {a} = {b}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.bijective_toCombination_one_equivariant | [286, 1] | [298, 8] | rintro ⟨s, hs⟩ | case right
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
⊢ Function.Surjective ⇑(toCombination_one_equivariant G α) | case right.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
s : Finset α
hs : s ∈ Combination α 1
⊢ ∃ a, (toCombination_one_equivariant G α) a = { val := s, property := hs } | Please generate a tactic in lean4 to solve the state.
STATE:
case right
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
⊢ Function.Surjective ⇑(toCombination_one_equivariant G α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.bijective_toCombination_one_equivariant | [286, 1] | [298, 8] | simp [Nat.Combination.mem_iff, Finset.card_eq_one] at hs | case right.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
s : Finset α
hs : s ∈ Combination α 1
⊢ ∃ a, (toCombination_one_equivariant G α) a = { val := s, property := hs } | case right.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
s : Finset α
hs✝ : s ∈ Combination α 1
hs : ∃ a, s = {a}
⊢ ∃ a, (toCombination_one_equivariant G α) a = { val := s, property := hs✝ } | Please generate a tactic in lean4 to solve the state.
STATE:
case right.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
s : Finset α
hs : s ∈ Combination α 1
⊢ ∃ a, (toCombination_one_equivariant G α) a = { val := s, property := hs }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.bijective_toCombination_one_equivariant | [286, 1] | [298, 8] | obtain ⟨a, ha⟩ := hs | case right.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
s : Finset α
hs✝ : s ∈ Combination α 1
hs : ∃ a, s = {a}
⊢ ∃ a, (toCombination_one_equivariant G α) a = { val := s, property := hs✝ } | case right.mk.intro
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
s : Finset α
hs : s ∈ Combination α 1
a : α
ha : s = {a}
⊢ ∃ a, (toCombination_one_equivariant G α) a = { val := s, property := hs } | Please generate a tactic in lean4 to solve the state.
STATE:
case right.mk
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
s : Finset α
hs✝ : s ∈ Combination α 1
hs : ∃ a, s = {a}
⊢ ∃ a, (toCombination_one_equivariant G α) a = { val := s, property := hs✝ }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.bijective_toCombination_one_equivariant | [286, 1] | [298, 8] | use a | case right.mk.intro
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
s : Finset α
hs : s ∈ Combination α 1
a : α
ha : s = {a}
⊢ ∃ a, (toCombination_one_equivariant G α) a = { val := s, property := hs } | case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
s : Finset α
hs : s ∈ Combination α 1
a : α
ha : s = {a}
⊢ (toCombination_one_equivariant G α) a = { val := s, property := hs } | Please generate a tactic in lean4 to solve the state.
STATE:
case right.mk.intro
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
s : Finset α
hs : s ∈ Combination α 1
a : α
ha : s = {a}
⊢ ∃ a, (toCombination_one_equivariant G α) a = { val := s, property := hs }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.bijective_toCombination_one_equivariant | [286, 1] | [298, 8] | simp only [toCombination_one_equivariant, ha] | case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
s : Finset α
hs : s ∈ Combination α 1
a : α
ha : s = {a}
⊢ (toCombination_one_equivariant G α) a = { val := s, property := hs } | case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
s : Finset α
hs : s ∈ Combination α 1
a : α
ha : s = {a}
⊢ { toFun := fun x => { val := {x}, property := ⋯ }, map_smul' := ⋯ } a = { val := {a}, property := ⋯ } | Please generate a tactic in lean4 to solve the state.
STATE:
case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
s : Finset α
hs : s ∈ Combination α 1
a : α
ha : s = {a}
⊢ (toCombination_one_equivariant G α) a = { val := s, property := hs }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MulActionCombination.lean | Nat.bijective_toCombination_one_equivariant | [286, 1] | [298, 8] | rfl | case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
s : Finset α
hs : s ∈ Combination α 1
a : α
ha : s = {a}
⊢ { toFun := fun x => { val := {x}, property := ⋯ }, map_smul' := ⋯ } a = { val := {a}, property := ⋯ } | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
G : Type u_1
inst✝³ : Group G
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : MulAction G α
n : ℕ
inst✝ : Fintype α
s : Finset α
hs : s ∈ Combination α 1
a : α
ha : s = {a}
⊢ { toFun := fun x => { val := {x}, property := ⋯ }, map_smul' := ⋯ } a = { val := {a}, property := ⋯ }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/EquivariantMap.lean | Set.image_smul_setₑ | [40, 1] | [44, 30] | change f.toFun '' ((fun a => m • a) '' s) = (fun b => φ m • b) '' (f.toFun '' s) | α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
φ : M → N
inst✝¹ : SMul M α
inst✝ : SMul N β
f : α →ₑ[φ] β
m : M
s : Set α
⊢ ⇑f '' (m • s) = φ m • ⇑f '' s | α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
φ : M → N
inst✝¹ : SMul M α
inst✝ : SMul N β
f : α →ₑ[φ] β
m : M
s : Set α
⊢ f.toFun '' ((fun a => m • a) '' s) = (fun b => φ m • b) '' (f.toFun '' s) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
φ : M → N
inst✝¹ : SMul M α
inst✝ : SMul N β
f : α →ₑ[φ] β
m : M
s : Set α
⊢ ⇑f '' (m • s) = φ m • ⇑f '' s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/EquivariantMap.lean | Set.image_smul_setₑ | [40, 1] | [44, 30] | simp only [Set.image_image] | α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
φ : M → N
inst✝¹ : SMul M α
inst✝ : SMul N β
f : α →ₑ[φ] β
m : M
s : Set α
⊢ f.toFun '' ((fun a => m • a) '' s) = (fun b => φ m • b) '' (f.toFun '' s) | α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
φ : M → N
inst✝¹ : SMul M α
inst✝ : SMul N β
f : α →ₑ[φ] β
m : M
s : Set α
⊢ (fun x => f.toFun (m • x)) '' s = (fun x => φ m • f.toFun x) '' s | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
φ : M → N
inst✝¹ : SMul M α
inst✝ : SMul N β
f : α →ₑ[φ] β
m : M
s : Set α
⊢ f.toFun '' ((fun a => m • a) '' s) = (fun b => φ m • b) '' (f.toFun '' s)
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.