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/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | rw [stabilizer_index_of_pretransitive M hGX a] | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
htcard : Set.ncard t = k
this :
(Fintype.card α - 1 - Set.ncard t)! * Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) = (Fintype.card α - 1)!
⊢ Subgroup.index (stabilizer M a) * (Fintype.card α - 1)! = (Fintype.card α)! | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
htcard : Set.ncard t = k
this :
(Fintype.card α - 1 - Set.ncard t)! * Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) = (Fintype.card α - 1)!
⊢ Nat.card α * (Fintype.card α - 1)! = (Fintype.card α)! | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
htcard : Set.ncard t = k
this :
(Fintype.card α - 1 - Set.ncard t)! * Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) = (Fintype.card α - 1)!
⊢ Subgroup.index (stabilizer M a) * (Fintype.card α - 1)! = (Fintype.card α)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | rw [Nat.card_eq_fintype_card] | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
htcard : Set.ncard t = k
this :
(Fintype.card α - 1 - Set.ncard t)! * Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) = (Fintype.card α - 1)!
⊢ Nat.card α * (Fintype.card α - 1)! = (Fintype.card α)! | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
htcard : Set.ncard t = k
this :
(Fintype.card α - 1 - Set.ncard t)! * Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) = (Fintype.card α - 1)!
⊢ Fintype.card α * (Fintype.card α - 1)! = (Fintype.card α)! | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
htcard : Set.ncard t = k
this :
(Fintype.card α - 1 - Set.ncard t)! * Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) = (Fintype.card α - 1)!
⊢ Nat.card α * (Fintype.card α - 1)! = (Fintype.card α)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | apply Nat.mul_factorial_pred | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
htcard : Set.ncard t = k
this :
(Fintype.card α - 1 - Set.ncard t)! * Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) = (Fintype.card α - 1)!
⊢ Fintype.card α * (Fintype.card α - 1)! = (Fintype.card α)! | case hn
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
htcard : Set.ncard t = k
this :
(Fintype.card α - 1 - Set.ncard t)! * Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) = (Fintype.card α - 1)!
⊢ 0 < Fintype.card α | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
htcard : Set.ncard t = k
this :
(Fintype.card α - 1 - Set.ncard t)! * Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) = (Fintype.card α - 1)!
⊢ Fintype.card α * (Fintype.card α - 1)! = (Fintype.card α)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | rw [Fintype.card_pos_iff] | case hn
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
htcard : Set.ncard t = k
this :
(Fintype.card α - 1 - Set.ncard t)! * Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) = (Fintype.card α - 1)!
⊢ 0 < Fintype.card α | case hn
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
htcard : Set.ncard t = k
this :
(Fintype.card α - 1 - Set.ncard t)! * Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) = (Fintype.card α - 1)!
⊢ Nonempty α | Please generate a tactic in lean4 to solve the state.
STATE:
case hn
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
htcard : Set.ncard t = k
this :
(Fintype.card α - 1 - Set.ncard t)! * Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) = (Fintype.card α - 1)!
⊢ 0 < Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | use a | case hn
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
htcard : Set.ncard t = k
this :
(Fintype.card α - 1 - Set.ncard t)! * Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) = (Fintype.card α - 1)!
⊢ Nonempty α | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case hn
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
htcard : Set.ncard t = k
this :
(Fintype.card α - 1 - Set.ncard t)! * Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) = (Fintype.card α - 1)!
⊢ Nonempty α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | rw [add_comm] at hscard | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
htcard : Set.ncard t = k
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) * (Fintype.card α - 1 - Set.ncard t)! = (Fintype.card α - 1)! | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = Set.ncard t + 1
htcard : Set.ncard t = k
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) * (Fintype.card α - 1 - Set.ncard t)! = (Fintype.card α - 1)! | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
htcard : Set.ncard t = k
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) * (Fintype.card α - 1 - Set.ncard t)! = (Fintype.card α - 1)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | have := Nat.sub_eq_of_eq_add hscard | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = Set.ncard t + 1
htcard : Set.ncard t = k
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) * (Fintype.card α - 1 - Set.ncard t)! = (Fintype.card α - 1)! | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = Set.ncard t + 1
htcard : Set.ncard t = k
this : Set.ncard s - 1 = Set.ncard t
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) * (Fintype.card α - 1 - Set.ncard t)! = (Fintype.card α - 1)! | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = Set.ncard t + 1
htcard : Set.ncard t = k
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) * (Fintype.card α - 1 - Set.ncard t)! = (Fintype.card α - 1)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | simp only [hs, Nat.pred_succ] at this | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = Set.ncard t + 1
htcard : Set.ncard t = k
this : Set.ncard s - 1 = Set.ncard t
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) * (Fintype.card α - 1 - Set.ncard t)! = (Fintype.card α - 1)! | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = Set.ncard t + 1
htcard : Set.ncard t = k
this : succ k - 1 = Set.ncard t
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) * (Fintype.card α - 1 - Set.ncard t)! = (Fintype.card α - 1)! | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = Set.ncard t + 1
htcard : Set.ncard t = k
this : Set.ncard s - 1 = Set.ncard t
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) * (Fintype.card α - 1 - Set.ncard t)! = (Fintype.card α - 1)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | convert hrec (stabilizer M a) (SubMulAction.ofStabilizer M a)
((stabilizer.isMultiplyPretransitive M α hGX).mp hmk) htcard | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = Set.ncard t + 1
htcard : Set.ncard t = k
this : succ k - 1 = Set.ncard t
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) * (Fintype.card α - 1 - Set.ncard t)! = (Fintype.card α - 1)! | case h.e'_2.h.e'_6.h.e'_1.h.e'_5
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = Set.ncard t + 1
htcard : Set.ncard t = k
this : succ k - 1 = Set.ncard t
⊢ Fintype.card α - 1 = Fintype.card ↥(SubMulAction.ofStabilizer M a)
case h.e'_3.h.e'_1
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = Set.ncard t + 1
htcard : Set.ncard t = k
this : succ k - 1 = Set.ncard t
⊢ Fintype.card α - 1 = Fintype.card ↥(SubMulAction.ofStabilizer M a) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = Set.ncard t + 1
htcard : Set.ncard t = k
this : succ k - 1 = Set.ncard t
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) * (Fintype.card α - 1 - Set.ncard t)! = (Fintype.card α - 1)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | all_goals {
apply symm
convert Fintype.card_compl_set _
exact setFintype {a}ᶜ } | case h.e'_2.h.e'_6.h.e'_1.h.e'_5
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = Set.ncard t + 1
htcard : Set.ncard t = k
this : succ k - 1 = Set.ncard t
⊢ Fintype.card α - 1 = Fintype.card ↥(SubMulAction.ofStabilizer M a)
case h.e'_3.h.e'_1
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = Set.ncard t + 1
htcard : Set.ncard t = k
this : succ k - 1 = Set.ncard t
⊢ Fintype.card α - 1 = Fintype.card ↥(SubMulAction.ofStabilizer M a) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_2.h.e'_6.h.e'_1.h.e'_5
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = Set.ncard t + 1
htcard : Set.ncard t = k
this : succ k - 1 = Set.ncard t
⊢ Fintype.card α - 1 = Fintype.card ↥(SubMulAction.ofStabilizer M a)
case h.e'_3.h.e'_1
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = Set.ncard t + 1
htcard : Set.ncard t = k
this : succ k - 1 = Set.ncard t
⊢ Fintype.card α - 1 = Fintype.card ↥(SubMulAction.ofStabilizer M a)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | apply symm | case h.e'_3.h.e'_1
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = Set.ncard t + 1
htcard : Set.ncard t = k
this : succ k - 1 = Set.ncard t
⊢ Fintype.card α - 1 = Fintype.card ↥(SubMulAction.ofStabilizer M a) | case h.e'_3.h.e'_1.a
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = Set.ncard t + 1
htcard : Set.ncard t = k
this : succ k - 1 = Set.ncard t
⊢ Fintype.card ↥(SubMulAction.ofStabilizer M a) = Fintype.card α - 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_1
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = Set.ncard t + 1
htcard : Set.ncard t = k
this : succ k - 1 = Set.ncard t
⊢ Fintype.card α - 1 = Fintype.card ↥(SubMulAction.ofStabilizer M a)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | convert Fintype.card_compl_set _ | case h.e'_3.h.e'_1.a
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = Set.ncard t + 1
htcard : Set.ncard t = k
this : succ k - 1 = Set.ncard t
⊢ Fintype.card ↥(SubMulAction.ofStabilizer M a) = Fintype.card α - 1 | case h.e'_3.h.e'_1.a.convert_5
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = Set.ncard t + 1
htcard : Set.ncard t = k
this : succ k - 1 = Set.ncard t
⊢ Fintype ↑{a}ᶜ | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_1.a
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = Set.ncard t + 1
htcard : Set.ncard t = k
this : succ k - 1 = Set.ncard t
⊢ Fintype.card ↥(SubMulAction.ofStabilizer M a) = Fintype.card α - 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | exact setFintype {a}ᶜ | case h.e'_3.h.e'_1.a.convert_5
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = Set.ncard t + 1
htcard : Set.ncard t = k
this : succ k - 1 = Set.ncard t
⊢ Fintype ↑{a}ᶜ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_1.a.convert_5
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = Set.ncard t + 1
htcard : Set.ncard t = k
this : succ k - 1 = Set.ncard t
⊢ Fintype ↑{a}ᶜ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixingSubgroup' | [902, 1] | [910, 34] | apply Nat.eq_of_mul_eq_mul_right (Nat.factorial_pos _) | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
s : Set α
hMk : IsMultiplyPretransitive M α (Set.ncard s)
⊢ Subgroup.index (fixingSubgroup M s) = choose (Fintype.card α) (Set.ncard s) * (Set.ncard s)! | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
s : Set α
hMk : IsMultiplyPretransitive M α (Set.ncard s)
⊢ Subgroup.index (fixingSubgroup M s) * ?m.226642! = choose (Fintype.card α) (Set.ncard s) * (Set.ncard s)! * ?m.226642!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
s : Set α
hMk : IsMultiplyPretransitive M α (Set.ncard s)
⊢ ℕ | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
s : Set α
hMk : IsMultiplyPretransitive M α (Set.ncard s)
⊢ Subgroup.index (fixingSubgroup M s) = choose (Fintype.card α) (Set.ncard s) * (Set.ncard s)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixingSubgroup' | [902, 1] | [910, 34] | rw [IsMultiplyPretransitive.index_of_fixingSubgroup M α s hMk] | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
s : Set α
hMk : IsMultiplyPretransitive M α (Set.ncard s)
⊢ Subgroup.index (fixingSubgroup M s) * ?m.226642! = choose (Fintype.card α) (Set.ncard s) * (Set.ncard s)! * ?m.226642!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
s : Set α
hMk : IsMultiplyPretransitive M α (Set.ncard s)
⊢ ℕ | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
s : Set α
hMk : IsMultiplyPretransitive M α (Set.ncard s)
⊢ (Fintype.card α)! = choose (Fintype.card α) (Set.ncard s) * (Set.ncard s)! * (Fintype.card α - Set.ncard s)! | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
s : Set α
hMk : IsMultiplyPretransitive M α (Set.ncard s)
⊢ Subgroup.index (fixingSubgroup M s) * ?m.226642! = choose (Fintype.card α) (Set.ncard s) * (Set.ncard s)! * ?m.226642!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
s : Set α
hMk : IsMultiplyPretransitive M α (Set.ncard s)
⊢ ℕ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixingSubgroup' | [902, 1] | [910, 34] | rw [Nat.choose_mul_factorial_mul_factorial] | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
s : Set α
hMk : IsMultiplyPretransitive M α (Set.ncard s)
⊢ (Fintype.card α)! = choose (Fintype.card α) (Set.ncard s) * (Set.ncard s)! * (Fintype.card α - Set.ncard s)! | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
s : Set α
hMk : IsMultiplyPretransitive M α (Set.ncard s)
⊢ Set.ncard s ≤ Fintype.card α | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
s : Set α
hMk : IsMultiplyPretransitive M α (Set.ncard s)
⊢ (Fintype.card α)! = choose (Fintype.card α) (Set.ncard s) * (Set.ncard s)! * (Fintype.card α - Set.ncard s)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixingSubgroup' | [902, 1] | [910, 34] | apply Set.ncard_le_fintype_card | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
s : Set α
hMk : IsMultiplyPretransitive M α (Set.ncard s)
⊢ Set.ncard s ≤ Fintype.card α | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
s : Set α
hMk : IsMultiplyPretransitive M α (Set.ncard s)
⊢ Set.ncard s ≤ Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | PartENat.lt_coe_succ_iff_le' | [912, 1] | [917, 90] | by_cases hx : x = ⊤ | M : Type ?u.226745
α : Type ?u.226748
inst✝¹ : Group M
inst✝ : MulAction M α
x : PartENat
n : ℕ
⊢ x < ↑(succ n) ↔ x ≤ ↑n | case pos
M : Type ?u.226745
α : Type ?u.226748
inst✝¹ : Group M
inst✝ : MulAction M α
x : PartENat
n : ℕ
hx : x = ⊤
⊢ x < ↑(succ n) ↔ x ≤ ↑n
case neg
M : Type ?u.226745
α : Type ?u.226748
inst✝¹ : Group M
inst✝ : MulAction M α
x : PartENat
n : ℕ
hx : ¬x = ⊤
⊢ x < ↑(succ n) ↔ x ≤ ↑n | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type ?u.226745
α : Type ?u.226748
inst✝¹ : Group M
inst✝ : MulAction M α
x : PartENat
n : ℕ
⊢ x < ↑(succ n) ↔ x ≤ ↑n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | PartENat.lt_coe_succ_iff_le' | [912, 1] | [917, 90] | rw [hx] | case pos
M : Type ?u.226745
α : Type ?u.226748
inst✝¹ : Group M
inst✝ : MulAction M α
x : PartENat
n : ℕ
hx : x = ⊤
⊢ x < ↑(succ n) ↔ x ≤ ↑n | case pos
M : Type ?u.226745
α : Type ?u.226748
inst✝¹ : Group M
inst✝ : MulAction M α
x : PartENat
n : ℕ
hx : x = ⊤
⊢ ⊤ < ↑(succ n) ↔ ⊤ ≤ ↑n | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
M : Type ?u.226745
α : Type ?u.226748
inst✝¹ : Group M
inst✝ : MulAction M α
x : PartENat
n : ℕ
hx : x = ⊤
⊢ x < ↑(succ n) ↔ x ≤ ↑n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | PartENat.lt_coe_succ_iff_le' | [912, 1] | [917, 90] | simp only [cast_succ, not_top_lt, top_le_iff, PartENat.natCast_ne_top] | case pos
M : Type ?u.226745
α : Type ?u.226748
inst✝¹ : Group M
inst✝ : MulAction M α
x : PartENat
n : ℕ
hx : x = ⊤
⊢ ⊤ < ↑(succ n) ↔ ⊤ ≤ ↑n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
M : Type ?u.226745
α : Type ?u.226748
inst✝¹ : Group M
inst✝ : MulAction M α
x : PartENat
n : ℕ
hx : x = ⊤
⊢ ⊤ < ↑(succ n) ↔ ⊤ ≤ ↑n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | PartENat.lt_coe_succ_iff_le' | [912, 1] | [917, 90] | rw [Nat.succ_eq_add_one n, Nat.cast_add, Nat.cast_one, PartENat.lt_add_one_iff_lt hx] | case neg
M : Type ?u.226745
α : Type ?u.226748
inst✝¹ : Group M
inst✝ : MulAction M α
x : PartENat
n : ℕ
hx : ¬x = ⊤
⊢ x < ↑(succ n) ↔ x ≤ ↑n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
M : Type ?u.226745
α : Type ?u.226748
inst✝¹ : Group M
inst✝ : MulAction M α
x : PartENat
n : ℕ
hx : ¬x = ⊤
⊢ x < ↑(succ n) ↔ x ≤ ↑n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | by_cases hα : Subsingleton α | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
⊢ IsPreprimitive M α | case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : Subsingleton α
⊢ IsPreprimitive M α
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
⊢ IsPreprimitive M α | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
⊢ IsPreprimitive M α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | have hα' : 2 ≤ PartENat.card α := by
rw [← PartENat.card_le_one_iff_subsingleton, not_le] at hα
exact PartENat.coe_succ_le_iff.mpr hα | case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
⊢ IsPreprimitive M α | case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
⊢ IsPreprimitive M α | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
⊢ IsPreprimitive M α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | have : IsPretransitive M α := by
rw [isPretransitive_iff_is_one_pretransitive]
apply isMultiplyPretransitive_of_higher M α h2
norm_num
exact hα' | case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
⊢ IsPreprimitive M α | case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
⊢ IsPreprimitive M α | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
⊢ IsPreprimitive M α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | apply IsPreprimitive.mk | case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
⊢ IsPreprimitive M α | case neg.has_trivial_blocks'
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
⊢ ∀ {B : Set α}, IsBlock M B → IsTrivialBlock B | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
⊢ IsPreprimitive M α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | intro B hB | case neg.has_trivial_blocks'
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
⊢ ∀ {B : Set α}, IsBlock M B → IsTrivialBlock B | case neg.has_trivial_blocks'
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
⊢ IsTrivialBlock B | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.has_trivial_blocks'
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
⊢ ∀ {B : Set α}, IsBlock M B → IsTrivialBlock B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | cases' B.subsingleton_or_nontrivial with h h | case neg.has_trivial_blocks'
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
⊢ IsTrivialBlock B | case neg.has_trivial_blocks'.inl
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
h : Set.Subsingleton B
⊢ IsTrivialBlock B
case neg.has_trivial_blocks'.inr
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
h : Set.Nontrivial B
⊢ IsTrivialBlock B | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.has_trivial_blocks'
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
⊢ IsTrivialBlock B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | apply IsPreprimitive.on_subsingleton | case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : Subsingleton α
⊢ IsPreprimitive M α | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : Subsingleton α
⊢ IsPreprimitive M α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | rw [← PartENat.card_le_one_iff_subsingleton, not_le] at hα | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
⊢ 2 ≤ PartENat.card α | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : 1 < PartENat.card α
⊢ 2 ≤ PartENat.card α | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
⊢ 2 ≤ PartENat.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | exact PartENat.coe_succ_le_iff.mpr hα | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : 1 < PartENat.card α
⊢ 2 ≤ PartENat.card α | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : 1 < PartENat.card α
⊢ 2 ≤ PartENat.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | rw [isPretransitive_iff_is_one_pretransitive] | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
⊢ IsPretransitive M α | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
⊢ IsMultiplyPretransitive M α 1 | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
⊢ IsPretransitive M α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | apply isMultiplyPretransitive_of_higher M α h2 | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
⊢ IsMultiplyPretransitive M α 1 | case hmn
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
⊢ 1 ≤ 2
case hα
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
⊢ ↑2 ≤ PartENat.card α | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
⊢ IsMultiplyPretransitive M α 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | norm_num | case hmn
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
⊢ 1 ≤ 2
case hα
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
⊢ ↑2 ≤ PartENat.card α | case hα
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
⊢ ↑2 ≤ PartENat.card α | Please generate a tactic in lean4 to solve the state.
STATE:
case hmn
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
⊢ 1 ≤ 2
case hα
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
⊢ ↑2 ≤ PartENat.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | exact hα' | case hα
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
⊢ ↑2 ≤ PartENat.card α | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case hα
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
⊢ ↑2 ≤ PartENat.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | left | case neg.has_trivial_blocks'.inl
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
h : Set.Subsingleton B
⊢ IsTrivialBlock B | case neg.has_trivial_blocks'.inl.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
h : Set.Subsingleton B
⊢ Set.Subsingleton B | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.has_trivial_blocks'.inl
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
h : Set.Subsingleton B
⊢ IsTrivialBlock B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | exact h | case neg.has_trivial_blocks'.inl.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
h : Set.Subsingleton B
⊢ Set.Subsingleton B | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.has_trivial_blocks'.inl.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
h : Set.Subsingleton B
⊢ Set.Subsingleton B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | right | case neg.has_trivial_blocks'.inr
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
h : Set.Nontrivial B
⊢ IsTrivialBlock B | case neg.has_trivial_blocks'.inr.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
h : Set.Nontrivial B
⊢ B = ⊤ | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.has_trivial_blocks'.inr
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
h : Set.Nontrivial B
⊢ IsTrivialBlock B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | obtain ⟨a, ha, b, hb, h⟩ := h | case neg.has_trivial_blocks'.inr.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
h : Set.Nontrivial B
⊢ B = ⊤ | case neg.has_trivial_blocks'.inr.h.intro.intro.intro.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
⊢ B = ⊤ | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.has_trivial_blocks'.inr.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
h : Set.Nontrivial B
⊢ B = ⊤
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | rw [eq_top_iff] | case neg.has_trivial_blocks'.inr.h.intro.intro.intro.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
⊢ B = ⊤ | case neg.has_trivial_blocks'.inr.h.intro.intro.intro.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
⊢ ⊤ ≤ B | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.has_trivial_blocks'.inr.h.intro.intro.intro.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
⊢ B = ⊤
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | intro c _ | case neg.has_trivial_blocks'.inr.h.intro.intro.intro.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
⊢ ⊤ ≤ B | case neg.has_trivial_blocks'.inr.h.intro.intro.intro.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
⊢ c ∈ B | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.has_trivial_blocks'.inr.h.intro.intro.intro.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
⊢ ⊤ ≤ B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | by_cases h' : a = c | case neg.has_trivial_blocks'.inr.h.intro.intro.intro.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
⊢ c ∈ B | case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : a = c
⊢ c ∈ B
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
⊢ c ∈ B | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.has_trivial_blocks'.inr.h.intro.intro.intro.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
⊢ c ∈ B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | rw [← h'] | case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : a = c
⊢ c ∈ B | case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : a = c
⊢ a ∈ B | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : a = c
⊢ c ∈ B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | exact ha | case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : a = c
⊢ a ∈ B | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : a = c
⊢ a ∈ B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | rw [IsBlock.mk_subset] at hB | case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
⊢ c ∈ B | case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : ∀ {g : M} {b : α}, b ∈ B → b ∈ g • B → g • B ≤ B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
⊢ c ∈ B | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : IsBlock M B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
⊢ c ∈ B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | rw [is_two_pretransitive_iff] at h2 | case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : ∀ {g : M} {b : α}, b ∈ B → b ∈ g • B → g • B ≤ B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
⊢ c ∈ B | case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : ∀ {g : M} {b : α}, b ∈ B → b ∈ g • B → g • B ≤ B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
⊢ c ∈ B | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : IsMultiplyPretransitive M α 2
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : ∀ {g : M} {b : α}, b ∈ B → b ∈ g • B → g • B ≤ B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
⊢ c ∈ B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | obtain ⟨g, hga, hgb⟩ := h2 a b a c h h' | case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : ∀ {g : M} {b : α}, b ∈ B → b ∈ g • B → g • B ≤ B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
⊢ c ∈ B | case neg.intro.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : ∀ {g : M} {b : α}, b ∈ B → b ∈ g • B → g • B ≤ B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
g : M
hga : g • a = a
hgb : g • b = c
⊢ c ∈ B | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : ∀ {g : M} {b : α}, b ∈ B → b ∈ g • B → g • B ≤ B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
⊢ c ∈ B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | apply hB ha | case neg.intro.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : ∀ {g : M} {b : α}, b ∈ B → b ∈ g • B → g • B ≤ B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
g : M
hga : g • a = a
hgb : g • b = c
⊢ c ∈ B | case neg.intro.intro.x
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : ∀ {g : M} {b : α}, b ∈ B → b ∈ g • B → g • B ≤ B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
g : M
hga : g • a = a
hgb : g • b = c
⊢ a ∈ ?m.235992 • B
case neg.intro.intro.a
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : ∀ {g : M} {b : α}, b ∈ B → b ∈ g • B → g • B ≤ B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
g : M
hga : g • a = a
hgb : g • b = c
⊢ c ∈ ?m.235992 • B
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : ∀ {g : M} {b : α}, b ∈ B → b ∈ g • B → g • B ≤ B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
g : M
hga : g • a = a
hgb : g • b = c
⊢ M | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.intro.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : ∀ {g : M} {b : α}, b ∈ B → b ∈ g • B → g • B ≤ B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
g : M
hga : g • a = a
hgb : g • b = c
⊢ c ∈ B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | rw [← hga] | case neg.intro.intro.x
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : ∀ {g : M} {b : α}, b ∈ B → b ∈ g • B → g • B ≤ B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
g : M
hga : g • a = a
hgb : g • b = c
⊢ a ∈ ?m.235992 • B | case neg.intro.intro.x
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : ∀ {g : M} {b : α}, b ∈ B → b ∈ g • B → g • B ≤ B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
g : M
hga : g • a = a
hgb : g • b = c
⊢ g • a ∈ ?m.235992 • B
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : ∀ {g : M} {b : α}, b ∈ B → b ∈ g • B → g • B ≤ B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
g : M
hga : g • a = a
hgb : g • b = c
⊢ M | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.intro.intro.x
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : ∀ {g : M} {b : α}, b ∈ B → b ∈ g • B → g • B ≤ B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
g : M
hga : g • a = a
hgb : g • b = c
⊢ a ∈ ?m.235992 • B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | exact Set.smul_mem_smul_set ha | case neg.intro.intro.x
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : ∀ {g : M} {b : α}, b ∈ B → b ∈ g • B → g • B ≤ B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
g : M
hga : g • a = a
hgb : g • b = c
⊢ g • a ∈ ?m.235992 • B
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : ∀ {g : M} {b : α}, b ∈ B → b ∈ g • B → g • B ≤ B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
g : M
hga : g • a = a
hgb : g • b = c
⊢ M | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.intro.intro.x
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : ∀ {g : M} {b : α}, b ∈ B → b ∈ g • B → g • B ≤ B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
g : M
hga : g • a = a
hgb : g • b = c
⊢ g • a ∈ ?m.235992 • B
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : ∀ {g : M} {b : α}, b ∈ B → b ∈ g • B → g • B ≤ B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
g : M
hga : g • a = a
hgb : g • b = c
⊢ M
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | rw [← hgb] | case neg.intro.intro.a
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : ∀ {g : M} {b : α}, b ∈ B → b ∈ g • B → g • B ≤ B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
g : M
hga : g • a = a
hgb : g • b = c
⊢ c ∈ g • B | case neg.intro.intro.a
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : ∀ {g : M} {b : α}, b ∈ B → b ∈ g • B → g • B ≤ B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
g : M
hga : g • a = a
hgb : g • b = c
⊢ g • b ∈ g • B | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.intro.intro.a
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : ∀ {g : M} {b : α}, b ∈ B → b ∈ g • B → g • B ≤ B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
g : M
hga : g • a = a
hgb : g • b = c
⊢ c ∈ g • B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.isPreprimitive_of_two | [920, 1] | [953, 39] | exact Set.smul_mem_smul_set hb | case neg.intro.intro.a
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : ∀ {g : M} {b : α}, b ∈ B → b ∈ g • B → g • B ≤ B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
g : M
hga : g • a = a
hgb : g • b = c
⊢ g • b ∈ g • B | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.intro.intro.a
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
h2 : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
hα : ¬Subsingleton α
hα' : 2 ≤ PartENat.card α
this : IsPretransitive M α
B : Set α
hB : ∀ {g : M} {b : α}, b ∈ B → b ∈ g • B → g • B ≤ B
a : α
ha : a ∈ B
b : α
hb : b ∈ B
h : a ≠ b
c : α
a✝ : c ∈ ⊤
h' : ¬a = c
g : M
hga : g • a = a
hgb : g • b = c
⊢ g • b ∈ g • B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isPretransitive | [959, 1] | [965, 33] | apply IsPretransitive.mk | M : Type ?u.237454
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : DecidableEq α
⊢ IsPretransitive (Equiv.Perm α) α | case exists_smul_eq
M : Type ?u.237454
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : DecidableEq α
⊢ ∀ (x y : α), ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type ?u.237454
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : DecidableEq α
⊢ IsPretransitive (Equiv.Perm α) α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isPretransitive | [959, 1] | [965, 33] | intro x y | case exists_smul_eq
M : Type ?u.237454
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : DecidableEq α
⊢ ∀ (x y : α), ∃ g, g • x = y | case exists_smul_eq
M : Type ?u.237454
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : DecidableEq α
x y : α
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq
M : Type ?u.237454
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : DecidableEq α
⊢ ∀ (x y : α), ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isPretransitive | [959, 1] | [965, 33] | use Equiv.swap x y | case exists_smul_eq
M : Type ?u.237454
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : DecidableEq α
x y : α
⊢ ∃ g, g • x = y | case h
M : Type ?u.237454
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : DecidableEq α
x y : α
⊢ Equiv.swap x y • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq
M : Type ?u.237454
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : DecidableEq α
x y : α
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isPretransitive | [959, 1] | [965, 33] | simp only [Equiv.Perm.smul_def] | case h
M : Type ?u.237454
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : DecidableEq α
x y : α
⊢ Equiv.swap x y • x = y | case h
M : Type ?u.237454
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : DecidableEq α
x y : α
⊢ (Equiv.swap x y) x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type ?u.237454
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : DecidableEq α
x y : α
⊢ Equiv.swap x y • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isPretransitive | [959, 1] | [965, 33] | rw [Equiv.swap_apply_left x y] | case h
M : Type ?u.237454
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : DecidableEq α
x y : α
⊢ (Equiv.swap x y) x = y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type ?u.237454
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : DecidableEq α
x y : α
⊢ (Equiv.swap x y) x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | cases' le_or_gt n (Fintype.card α) with hn hn | M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
⊢ IsMultiplyPretransitive (Equiv.Perm α) α n | case inl
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
⊢ IsMultiplyPretransitive (Equiv.Perm α) α n
case inr
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n > Fintype.card α
⊢ IsMultiplyPretransitive (Equiv.Perm α) α n | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
⊢ IsMultiplyPretransitive (Equiv.Perm α) α n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | suffices IsEmpty (Fin n ↪ α) by
apply IsPretransitive.mk
intro x
exfalso
exact this.false x | case inr
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n > Fintype.card α
⊢ IsMultiplyPretransitive (Equiv.Perm α) α n | case inr
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n > Fintype.card α
⊢ IsEmpty (Fin n ↪ α) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n > Fintype.card α
⊢ IsMultiplyPretransitive (Equiv.Perm α) α n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | apply Function.Embedding.isEmpty_of_card_lt | case inr
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n > Fintype.card α
⊢ IsEmpty (Fin n ↪ α) | case inr.h
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n > Fintype.card α
⊢ Fintype.card α < Fintype.card (Fin n) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n > Fintype.card α
⊢ IsEmpty (Fin n ↪ α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | simp only [Fintype.card_fin] | case inr.h
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n > Fintype.card α
⊢ Fintype.card α < Fintype.card (Fin n) | case inr.h
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n > Fintype.card α
⊢ Fintype.card α < n | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.h
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n > Fintype.card α
⊢ Fintype.card α < Fintype.card (Fin n)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | exact hn | case inr.h
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n > Fintype.card α
⊢ Fintype.card α < n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.h
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n > Fintype.card α
⊢ Fintype.card α < n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | apply isMultiplyPretransitive_of_higher (Equiv.Perm α) α _ hn | case inl
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
⊢ IsMultiplyPretransitive (Equiv.Perm α) α n | case inl
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
⊢ ↑(Fintype.card α) ≤ PartENat.card α
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
⊢ IsMultiplyPretransitive (Equiv.Perm α) α (Fintype.card α) | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
⊢ IsMultiplyPretransitive (Equiv.Perm α) α n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | apply le_of_eq | case inl
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
⊢ ↑(Fintype.card α) ≤ PartENat.card α
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
⊢ IsMultiplyPretransitive (Equiv.Perm α) α (Fintype.card α) | case inl.a
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
⊢ ↑(Fintype.card α) = PartENat.card α
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
⊢ IsMultiplyPretransitive (Equiv.Perm α) α (Fintype.card α) | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
⊢ ↑(Fintype.card α) ≤ PartENat.card α
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
⊢ IsMultiplyPretransitive (Equiv.Perm α) α (Fintype.card α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | rw [PartENat.card_eq_coe_fintype_card] | case inl.a
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
⊢ ↑(Fintype.card α) = PartENat.card α
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
⊢ IsMultiplyPretransitive (Equiv.Perm α) α (Fintype.card α) | M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
⊢ IsMultiplyPretransitive (Equiv.Perm α) α (Fintype.card α) | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.a
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
⊢ ↑(Fintype.card α) = PartENat.card α
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
⊢ IsMultiplyPretransitive (Equiv.Perm α) α (Fintype.card α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | apply IsPretransitive.mk | M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
⊢ IsMultiplyPretransitive (Equiv.Perm α) α (Fintype.card α) | case exists_smul_eq
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
⊢ ∀ (x y : Fin (Fintype.card α) ↪ α), ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
⊢ IsMultiplyPretransitive (Equiv.Perm α) α (Fintype.card α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | intro x y | case exists_smul_eq
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
⊢ ∀ (x y : Fin (Fintype.card α) ↪ α), ∃ g, g • x = y | case exists_smul_eq
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
⊢ ∀ (x y : Fin (Fintype.card α) ↪ α), ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | suffices h : Function.Bijective x ∧ Function.Bijective y by
let x' := Equiv.ofBijective x h.1
let y' := Equiv.ofBijective y h.2
use x'.symm.trans y'
ext i
simp only [smul_apply, Equiv.Perm.smul_def, Equiv.trans_apply, x', y']
simp only [Equiv.ofBijective_symm_apply_apply, Equiv.ofBijective_apply] | case exists_smul_eq
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ ∃ g, g • x = y | case exists_smul_eq
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ Function.Bijective ⇑x ∧ Function.Bijective ⇑y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | constructor | case exists_smul_eq
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ Function.Bijective ⇑x ∧ Function.Bijective ⇑y | case exists_smul_eq.left
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ Function.Bijective ⇑x
case exists_smul_eq.right
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ Function.Bijective ⇑y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ Function.Bijective ⇑x ∧ Function.Bijective ⇑y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | all_goals
rw [Fintype.bijective_iff_injective_and_card]
constructor
apply EmbeddingLike.injective
exact Fintype.card_fin (Fintype.card α) | case exists_smul_eq.left
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ Function.Bijective ⇑x
case exists_smul_eq.right
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ Function.Bijective ⇑y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq.left
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ Function.Bijective ⇑x
case exists_smul_eq.right
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ Function.Bijective ⇑y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | let x' := Equiv.ofBijective x h.1 | M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
h : Function.Bijective ⇑x ∧ Function.Bijective ⇑y
⊢ ∃ g, g • x = y | M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
h : Function.Bijective ⇑x ∧ Function.Bijective ⇑y
x' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑x ⋯
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
h : Function.Bijective ⇑x ∧ Function.Bijective ⇑y
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | let y' := Equiv.ofBijective y h.2 | M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
h : Function.Bijective ⇑x ∧ Function.Bijective ⇑y
x' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑x ⋯
⊢ ∃ g, g • x = y | M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
h : Function.Bijective ⇑x ∧ Function.Bijective ⇑y
x' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑x ⋯
y' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑y ⋯
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
h : Function.Bijective ⇑x ∧ Function.Bijective ⇑y
x' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑x ⋯
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | use x'.symm.trans y' | M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
h : Function.Bijective ⇑x ∧ Function.Bijective ⇑y
x' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑x ⋯
y' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑y ⋯
⊢ ∃ g, g • x = y | case h
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
h : Function.Bijective ⇑x ∧ Function.Bijective ⇑y
x' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑x ⋯
y' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑y ⋯
⊢ x'.symm.trans y' • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
h : Function.Bijective ⇑x ∧ Function.Bijective ⇑y
x' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑x ⋯
y' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑y ⋯
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | ext i | case h
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
h : Function.Bijective ⇑x ∧ Function.Bijective ⇑y
x' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑x ⋯
y' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑y ⋯
⊢ x'.symm.trans y' • x = y | case h.h
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
h : Function.Bijective ⇑x ∧ Function.Bijective ⇑y
x' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑x ⋯
y' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑y ⋯
i : Fin (Fintype.card α)
⊢ (x'.symm.trans y' • x) i = y i | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
h : Function.Bijective ⇑x ∧ Function.Bijective ⇑y
x' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑x ⋯
y' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑y ⋯
⊢ x'.symm.trans y' • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | simp only [smul_apply, Equiv.Perm.smul_def, Equiv.trans_apply, x', y'] | case h.h
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
h : Function.Bijective ⇑x ∧ Function.Bijective ⇑y
x' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑x ⋯
y' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑y ⋯
i : Fin (Fintype.card α)
⊢ (x'.symm.trans y' • x) i = y i | case h.h
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
h : Function.Bijective ⇑x ∧ Function.Bijective ⇑y
x' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑x ⋯
y' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑y ⋯
i : Fin (Fintype.card α)
⊢ (Equiv.ofBijective ⇑y ⋯) ((Equiv.ofBijective ⇑x ⋯).symm (x i)) = y i | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
h : Function.Bijective ⇑x ∧ Function.Bijective ⇑y
x' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑x ⋯
y' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑y ⋯
i : Fin (Fintype.card α)
⊢ (x'.symm.trans y' • x) i = y i
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | simp only [Equiv.ofBijective_symm_apply_apply, Equiv.ofBijective_apply] | case h.h
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
h : Function.Bijective ⇑x ∧ Function.Bijective ⇑y
x' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑x ⋯
y' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑y ⋯
i : Fin (Fintype.card α)
⊢ (Equiv.ofBijective ⇑y ⋯) ((Equiv.ofBijective ⇑x ⋯).symm (x i)) = y i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
h : Function.Bijective ⇑x ∧ Function.Bijective ⇑y
x' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑x ⋯
y' : Fin (Fintype.card α) ≃ α := Equiv.ofBijective ⇑y ⋯
i : Fin (Fintype.card α)
⊢ (Equiv.ofBijective ⇑y ⋯) ((Equiv.ofBijective ⇑x ⋯).symm (x i)) = y i
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | rw [Fintype.bijective_iff_injective_and_card] | case exists_smul_eq.right
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ Function.Bijective ⇑y | case exists_smul_eq.right
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ Function.Injective ⇑y ∧ Fintype.card (Fin (Fintype.card α)) = Fintype.card α | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq.right
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ Function.Bijective ⇑y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | constructor | case exists_smul_eq.right
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ Function.Injective ⇑y ∧ Fintype.card (Fin (Fintype.card α)) = Fintype.card α | case exists_smul_eq.right.left
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ Function.Injective ⇑y
case exists_smul_eq.right.right
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ Fintype.card (Fin (Fintype.card α)) = Fintype.card α | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq.right
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ Function.Injective ⇑y ∧ Fintype.card (Fin (Fintype.card α)) = Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | apply EmbeddingLike.injective | case exists_smul_eq.right.left
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ Function.Injective ⇑y
case exists_smul_eq.right.right
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ Fintype.card (Fin (Fintype.card α)) = Fintype.card α | case exists_smul_eq.right.right
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ Fintype.card (Fin (Fintype.card α)) = Fintype.card α | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq.right.left
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ Function.Injective ⇑y
case exists_smul_eq.right.right
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ Fintype.card (Fin (Fintype.card α)) = Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | exact Fintype.card_fin (Fintype.card α) | case exists_smul_eq.right.right
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ Fintype.card (Fin (Fintype.card α)) = Fintype.card α | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq.right.right
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n ≤ Fintype.card α
x y : Fin (Fintype.card α) ↪ α
⊢ Fintype.card (Fin (Fintype.card α)) = Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | apply IsPretransitive.mk | M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n > Fintype.card α
this : IsEmpty (Fin n ↪ α)
⊢ IsMultiplyPretransitive (Equiv.Perm α) α n | case exists_smul_eq
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n > Fintype.card α
this : IsEmpty (Fin n ↪ α)
⊢ ∀ (x y : Fin n ↪ α), ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n > Fintype.card α
this : IsEmpty (Fin n ↪ α)
⊢ IsMultiplyPretransitive (Equiv.Perm α) α n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | intro x | case exists_smul_eq
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n > Fintype.card α
this : IsEmpty (Fin n ↪ α)
⊢ ∀ (x y : Fin n ↪ α), ∃ g, g • x = y | case exists_smul_eq
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n > Fintype.card α
this : IsEmpty (Fin n ↪ α)
x : Fin n ↪ α
⊢ ∀ (y : Fin n ↪ α), ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n > Fintype.card α
this : IsEmpty (Fin n ↪ α)
⊢ ∀ (x y : Fin n ↪ α), ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | exfalso | case exists_smul_eq
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n > Fintype.card α
this : IsEmpty (Fin n ↪ α)
x : Fin n ↪ α
⊢ ∀ (y : Fin n ↪ α), ∃ g, g • x = y | case exists_smul_eq
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n > Fintype.card α
this : IsEmpty (Fin n ↪ α)
x : Fin n ↪ α
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n > Fintype.card α
this : IsEmpty (Fin n ↪ α)
x : Fin n ↪ α
⊢ ∀ (y : Fin n ↪ α), ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isMultiplyPretransitive | [971, 1] | [1000, 11] | exact this.false x | case exists_smul_eq
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n > Fintype.card α
this : IsEmpty (Fin n ↪ α)
x : Fin n ↪ α
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq
M : Type ?u.240457
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
n : ℕ
hn : n > Fintype.card α
this : IsEmpty (Fin n ↪ α)
x : Fin n ↪ α
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isPreprimitive | [1004, 1] | [1008, 43] | cases subsingleton_or_nontrivial α | M : Type ?u.243758
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
⊢ IsPreprimitive (Equiv.Perm α) α | case inl
M : Type ?u.243758
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
h✝ : Subsingleton α
⊢ IsPreprimitive (Equiv.Perm α) α
case inr
M : Type ?u.243758
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
h✝ : Nontrivial α
⊢ IsPreprimitive (Equiv.Perm α) α | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type ?u.243758
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
⊢ IsPreprimitive (Equiv.Perm α) α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isPreprimitive | [1004, 1] | [1008, 43] | apply IsMultiplyPretransitive.isPreprimitive_of_two | case inr
M : Type ?u.243758
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
h✝ : Nontrivial α
⊢ IsPreprimitive (Equiv.Perm α) α | case inr.h2
M : Type ?u.243758
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
h✝ : Nontrivial α
⊢ IsMultiplyPretransitive (Equiv.Perm α) α 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
M : Type ?u.243758
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
h✝ : Nontrivial α
⊢ IsPreprimitive (Equiv.Perm α) α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isPreprimitive | [1004, 1] | [1008, 43] | apply Equiv.Perm.isMultiplyPretransitive | case inr.h2
M : Type ?u.243758
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
h✝ : Nontrivial α
⊢ IsMultiplyPretransitive (Equiv.Perm α) α 2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.h2
M : Type ?u.243758
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
h✝ : Nontrivial α
⊢ IsMultiplyPretransitive (Equiv.Perm α) α 2
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Equiv.Perm.isPreprimitive | [1004, 1] | [1008, 43] | exact IsPreprimitive.on_subsingleton | case inl
M : Type ?u.243758
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
h✝ : Subsingleton α
⊢ IsPreprimitive (Equiv.Perm α) α | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
M : Type ?u.243758
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
h✝ : Subsingleton α
⊢ IsPreprimitive (Equiv.Perm α) α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.aux_lt_iff_lt_or_eq | [1013, 1] | [1021, 54] | rw [Nat.lt_iff_le_not_le] | M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
⊢ m < n - 1 ∨ m = n - 1 | M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
⊢ m ≤ n - 1 ∧ ¬n - 1 ≤ m ∨ m = n - 1 | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
⊢ m < n - 1 ∨ m = n - 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.aux_lt_iff_lt_or_eq | [1013, 1] | [1021, 54] | cases' dec_em (m = n - 1) with h h' | M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
⊢ m ≤ n - 1 ∧ ¬n - 1 ≤ m ∨ m = n - 1 | case inl
M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
h : m = n - 1
⊢ m ≤ n - 1 ∧ ¬n - 1 ≤ m ∨ m = n - 1
case inr
M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
h' : ¬m = n - 1
⊢ m ≤ n - 1 ∧ ¬n - 1 ≤ m ∨ m = n - 1 | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
⊢ m ≤ n - 1 ∧ ¬n - 1 ≤ m ∨ m = n - 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.aux_lt_iff_lt_or_eq | [1013, 1] | [1021, 54] | exact Or.intro_right _ h | case inl
M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
h : m = n - 1
⊢ m ≤ n - 1 ∧ ¬n - 1 ≤ m ∨ m = n - 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
h : m = n - 1
⊢ m ≤ n - 1 ∧ ¬n - 1 ≤ m ∨ m = n - 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.aux_lt_iff_lt_or_eq | [1013, 1] | [1021, 54] | apply Or.intro_left | case inr
M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
h' : ¬m = n - 1
⊢ m ≤ n - 1 ∧ ¬n - 1 ≤ m ∨ m = n - 1 | case inr.h
M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
h' : ¬m = n - 1
⊢ m ≤ n - 1 ∧ ¬n - 1 ≤ m | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
h' : ¬m = n - 1
⊢ m ≤ n - 1 ∧ ¬n - 1 ≤ m ∨ m = n - 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.aux_lt_iff_lt_or_eq | [1013, 1] | [1021, 54] | apply And.intro | case inr.h
M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
h' : ¬m = n - 1
⊢ m ≤ n - 1 ∧ ¬n - 1 ≤ m | case inr.h.left
M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
h' : ¬m = n - 1
⊢ m ≤ n - 1
case inr.h.right
M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
h' : ¬m = n - 1
⊢ ¬n - 1 ≤ m | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.h
M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
h' : ¬m = n - 1
⊢ m ≤ n - 1 ∧ ¬n - 1 ≤ m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.aux_lt_iff_lt_or_eq | [1013, 1] | [1021, 54] | exact Nat.le_pred_of_lt hmn | case inr.h.left
M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
h' : ¬m = n - 1
⊢ m ≤ n - 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.h.left
M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
h' : ¬m = n - 1
⊢ m ≤ n - 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.aux_lt_iff_lt_or_eq | [1013, 1] | [1021, 54] | intro h | case inr.h.right
M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
h' : ¬m = n - 1
⊢ ¬n - 1 ≤ m | case inr.h.right
M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
h' : ¬m = n - 1
h : n - 1 ≤ m
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.h.right
M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
h' : ¬m = n - 1
⊢ ¬n - 1 ≤ m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.aux_lt_iff_lt_or_eq | [1013, 1] | [1021, 54] | apply h' | case inr.h.right
M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
h' : ¬m = n - 1
h : n - 1 ≤ m
⊢ False | case inr.h.right
M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
h' : ¬m = n - 1
h : n - 1 ≤ m
⊢ m = n - 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.h.right
M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
h' : ¬m = n - 1
h : n - 1 ≤ m
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.aux_lt_iff_lt_or_eq | [1013, 1] | [1021, 54] | exact Nat.le_antisymm (Nat.le_pred_of_lt hmn) h | case inr.h.right
M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
h' : ¬m = n - 1
h : n - 1 ≤ m
⊢ m = n - 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.h.right
M : Type ?u.247599
α : Type ?u.247602
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
m n : ℕ
hmn : m < n
h' : ¬m = n - 1
h : n - 1 ≤ m
⊢ m = n - 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.eq_top_of_is_full_minus_one_pretransitive | [1025, 1] | [1065, 6] | let j : Fin (Fintype.card α - 1) ↪ Fin (Fintype.card α) :=
(Fin.castLEEmb ((Fintype.card α).sub_le 1)).toEmbedding | M : Type ?u.248388
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
G : Subgroup (Equiv.Perm α)
hmt : IsMultiplyPretransitive (↥G) α (Fintype.card α - 1)
⊢ G = ⊤ | M : Type ?u.248388
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
G : Subgroup (Equiv.Perm α)
hmt : IsMultiplyPretransitive (↥G) α (Fintype.card α - 1)
j : Fin (Fintype.card α - 1) ↪ Fin (Fintype.card α) := (Fin.castLEEmb ⋯).toEmbedding
⊢ G = ⊤ | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type ?u.248388
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
G : Subgroup (Equiv.Perm α)
hmt : IsMultiplyPretransitive (↥G) α (Fintype.card α - 1)
⊢ G = ⊤
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.eq_top_of_is_full_minus_one_pretransitive | [1025, 1] | [1065, 6] | rw [eq_top_iff] | M : Type ?u.248388
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
G : Subgroup (Equiv.Perm α)
hmt : IsMultiplyPretransitive (↥G) α (Fintype.card α - 1)
j : Fin (Fintype.card α - 1) ↪ Fin (Fintype.card α) := (Fin.castLEEmb ⋯).toEmbedding
⊢ G = ⊤ | M : Type ?u.248388
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
G : Subgroup (Equiv.Perm α)
hmt : IsMultiplyPretransitive (↥G) α (Fintype.card α - 1)
j : Fin (Fintype.card α - 1) ↪ Fin (Fintype.card α) := (Fin.castLEEmb ⋯).toEmbedding
⊢ ⊤ ≤ G | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type ?u.248388
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
G : Subgroup (Equiv.Perm α)
hmt : IsMultiplyPretransitive (↥G) α (Fintype.card α - 1)
j : Fin (Fintype.card α - 1) ↪ Fin (Fintype.card α) := (Fin.castLEEmb ⋯).toEmbedding
⊢ G = ⊤
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.eq_top_of_is_full_minus_one_pretransitive | [1025, 1] | [1065, 6] | intro k _ | M : Type ?u.248388
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
G : Subgroup (Equiv.Perm α)
hmt : IsMultiplyPretransitive (↥G) α (Fintype.card α - 1)
j : Fin (Fintype.card α - 1) ↪ Fin (Fintype.card α) := (Fin.castLEEmb ⋯).toEmbedding
⊢ ⊤ ≤ G | M : Type ?u.248388
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
G : Subgroup (Equiv.Perm α)
hmt : IsMultiplyPretransitive (↥G) α (Fintype.card α - 1)
j : Fin (Fintype.card α - 1) ↪ Fin (Fintype.card α) := (Fin.castLEEmb ⋯).toEmbedding
k : Equiv.Perm α
a✝ : k ∈ ⊤
⊢ k ∈ G | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type ?u.248388
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
G : Subgroup (Equiv.Perm α)
hmt : IsMultiplyPretransitive (↥G) α (Fintype.card α - 1)
j : Fin (Fintype.card α - 1) ↪ Fin (Fintype.card α) := (Fin.castLEEmb ⋯).toEmbedding
⊢ ⊤ ≤ G
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.eq_top_of_is_full_minus_one_pretransitive | [1025, 1] | [1065, 6] | let x : Fin (Fintype.card α) ↪ α := (Fintype.equivFinOfCardEq rfl).symm.toEmbedding | M : Type ?u.248388
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
G : Subgroup (Equiv.Perm α)
hmt : IsMultiplyPretransitive (↥G) α (Fintype.card α - 1)
j : Fin (Fintype.card α - 1) ↪ Fin (Fintype.card α) := (Fin.castLEEmb ⋯).toEmbedding
k : Equiv.Perm α
a✝ : k ∈ ⊤
⊢ k ∈ G | M : Type ?u.248388
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
G : Subgroup (Equiv.Perm α)
hmt : IsMultiplyPretransitive (↥G) α (Fintype.card α - 1)
j : Fin (Fintype.card α - 1) ↪ Fin (Fintype.card α) := (Fin.castLEEmb ⋯).toEmbedding
k : Equiv.Perm α
a✝ : k ∈ ⊤
x : Fin (Fintype.card α) ↪ α := Equiv.toEmbedding (Fintype.equivFinOfCardEq ⋯).symm
⊢ k ∈ G | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type ?u.248388
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
G : Subgroup (Equiv.Perm α)
hmt : IsMultiplyPretransitive (↥G) α (Fintype.card α - 1)
j : Fin (Fintype.card α - 1) ↪ Fin (Fintype.card α) := (Fin.castLEEmb ⋯).toEmbedding
k : Equiv.Perm α
a✝ : k ∈ ⊤
⊢ k ∈ G
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.