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/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | exact hx | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
x : α
hx : x ∈ t
u : α
hu : u ∈ tᶜ
h : x = u
⊢ x ∈ t | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
x : α
hx : x ∈ t
u : α
hu : u ∈ tᶜ
h : x = u
⊢ x ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [hxa, Equiv.swap_apply_left] | case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
x : α
hx : x ∈ t
hx_ne : ∀ u ∈ tᶜ, x ≠ u
hxa : x = a
⊢ (Equiv.swap a b) x ∈ t | case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
x : α
hx : x ∈ t
hx_ne : ∀ u ∈ tᶜ, x ≠ u
hxa : x = a
⊢ b ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
x : α
hx : x ∈ t
hx_ne : ∀ u ∈ tᶜ, x ≠ u
hxa : x = a
⊢ (Equiv.swap a b) x ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | exact hb | case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
x : α
hx : x ∈ t
hx_ne : ∀ u ∈ tᶜ, x ≠ u
hxa : x = a
⊢ b ∈ t | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
x : α
hx : x ∈ t
hx_ne : ∀ u ∈ tᶜ, x ≠ u
hxa : x = a
⊢ b ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | by_cases hxb : x = b | case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
x : α
hx : x ∈ t
hx_ne : ∀ u ∈ tᶜ, x ≠ u
hxa : ¬x = a
⊢ (Equiv.swap a b) x ∈ t | case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
x : α
hx : x ∈ t
hx_ne : ∀ u ∈ tᶜ, x ≠ u
hxa : ¬x = a
hxb : x = b
⊢ (Equiv.swap a b) x ∈ t
case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
x : α
hx : x ∈ t
hx_ne : ∀ u ∈ tᶜ, x ≠ u
hxa : ¬x = a
hxb : ¬x = b
⊢ (Equiv.swap a b) x ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
x : α
hx : x ∈ t
hx_ne : ∀ u ∈ tᶜ, x ≠ u
hxa : ¬x = a
⊢ (Equiv.swap a b) x ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [hxb, Equiv.swap_apply_right] | case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
x : α
hx : x ∈ t
hx_ne : ∀ u ∈ tᶜ, x ≠ u
hxa : ¬x = a
hxb : x = b
⊢ (Equiv.swap a b) x ∈ t | case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
x : α
hx : x ∈ t
hx_ne : ∀ u ∈ tᶜ, x ≠ u
hxa : ¬x = a
hxb : x = b
⊢ a ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
x : α
hx : x ∈ t
hx_ne : ∀ u ∈ tᶜ, x ≠ u
hxa : ¬x = a
hxb : x = b
⊢ (Equiv.swap a b) x ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | exact ha | case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
x : α
hx : x ∈ t
hx_ne : ∀ u ∈ tᶜ, x ≠ u
hxa : ¬x = a
hxb : x = b
⊢ a ∈ t | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
x : α
hx : x ∈ t
hx_ne : ∀ u ∈ tᶜ, x ≠ u
hxa : ¬x = a
hxb : x = b
⊢ a ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [Equiv.swap_apply_of_ne_of_ne hxa hxb] | case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
x : α
hx : x ∈ t
hx_ne : ∀ u ∈ tᶜ, x ≠ u
hxa : ¬x = a
hxb : ¬x = b
⊢ (Equiv.swap a b) x ∈ t | case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
x : α
hx : x ∈ t
hx_ne : ∀ u ∈ tᶜ, x ≠ u
hxa : ¬x = a
hxb : ¬x = b
⊢ x ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
x : α
hx : x ∈ t
hx_ne : ∀ u ∈ tᶜ, x ≠ u
hxa : ¬x = a
hxb : ¬x = b
⊢ (Equiv.swap a b) x ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | exact hx | case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
x : α
hx : x ∈ t
hx_ne : ∀ u ∈ tᶜ, x ≠ u
hxa : ¬x = a
hxb : ¬x = b
⊢ x ∈ t | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
x : α
hx : x ∈ t
hx_ne : ∀ u ∈ tᶜ, x ≠ u
hxa : ¬x = a
hxb : ¬x = b
⊢ x ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | simp only [Equiv.Perm.mem_alternatingGroup, Equiv.Perm.sign_mul] | case h.left.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
⊢ Equiv.swap a b * Equiv.swap c d ∈ alternatingGroup α | case h.left.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
⊢ Equiv.Perm.sign (Equiv.swap a b) * Equiv.Perm.sign (Equiv.swap c d) = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
⊢ Equiv.swap a b * Equiv.swap c d ∈ alternatingGroup α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [Equiv.Perm.sign_swap hab] | case h.left.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
⊢ Equiv.Perm.sign (Equiv.swap a b) * Equiv.Perm.sign (Equiv.swap c d) = 1 | case h.left.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
⊢ -1 * Equiv.Perm.sign (Equiv.swap c d) = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
⊢ Equiv.Perm.sign (Equiv.swap a b) * Equiv.Perm.sign (Equiv.swap c d) = 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [Equiv.Perm.sign_swap hcd] | case h.left.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
⊢ -1 * Equiv.Perm.sign (Equiv.swap c d) = 1 | case h.left.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
⊢ -1 * -1 = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
⊢ -1 * Equiv.Perm.sign (Equiv.swap c d) = 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | simp only [Int.units_mul_self] | case h.left.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
⊢ -1 * -1 = 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
⊢ -1 * -1 = 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | simp only [Equiv.Perm.smul_def, Equiv.Perm.coe_mul, Function.comp_apply] | case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
⊢ (Equiv.swap a b * Equiv.swap c d) • a = b | case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
⊢ (Equiv.swap a b) ((Equiv.swap c d) a) = b | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
⊢ (Equiv.swap a b * Equiv.swap c d) • a = b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [Set.mem_compl_iff t] at hc hd | case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
⊢ (Equiv.swap a b) ((Equiv.swap c d) a) = b | case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
⊢ (Equiv.swap a b) ((Equiv.swap c d) a) = b | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∈ tᶜ
hd : d ∈ tᶜ
hcd : ¬c = d
⊢ (Equiv.swap a b) ((Equiv.swap c d) a) = b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | have hac : a ≠ c := by intro h; apply hc; rw [← h]; exact ha | case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
⊢ (Equiv.swap a b) ((Equiv.swap c d) a) = b | case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
hac : a ≠ c
⊢ (Equiv.swap a b) ((Equiv.swap c d) a) = b | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
⊢ (Equiv.swap a b) ((Equiv.swap c d) a) = b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | have had : a ≠ d := by intro h; apply hd; rw [← h]; exact ha | case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
hac : a ≠ c
⊢ (Equiv.swap a b) ((Equiv.swap c d) a) = b | case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
hac : a ≠ c
had : a ≠ d
⊢ (Equiv.swap a b) ((Equiv.swap c d) a) = b | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
hac : a ≠ c
⊢ (Equiv.swap a b) ((Equiv.swap c d) a) = b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [Equiv.swap_apply_of_ne_of_ne hac had] | case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
hac : a ≠ c
had : a ≠ d
⊢ (Equiv.swap a b) ((Equiv.swap c d) a) = b | case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
hac : a ≠ c
had : a ≠ d
⊢ (Equiv.swap a b) a = b | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
hac : a ≠ c
had : a ≠ d
⊢ (Equiv.swap a b) ((Equiv.swap c d) a) = b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [Equiv.swap_apply_left] | case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
hac : a ≠ c
had : a ≠ d
⊢ (Equiv.swap a b) a = b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
hac : a ≠ c
had : a ≠ d
⊢ (Equiv.swap a b) a = b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | intro h | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
⊢ a ≠ c | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
h : a = c
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
⊢ a ≠ c
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | apply hc | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
h : a = c
⊢ False | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
h : a = c
⊢ c ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
h : a = c
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [← h] | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
h : a = c
⊢ c ∈ t | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
h : a = c
⊢ a ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
h : a = c
⊢ c ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | exact ha | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
h : a = c
⊢ a ∈ t | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
h : a = c
⊢ a ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | intro h | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
hac : a ≠ c
⊢ a ≠ d | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
hac : a ≠ c
h : a = d
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
hac : a ≠ c
⊢ a ≠ d
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | apply hd | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
hac : a ≠ c
h : a = d
⊢ False | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
hac : a ≠ c
h : a = d
⊢ d ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
hac : a ≠ c
h : a = d
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [← h] | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
hac : a ≠ c
h : a = d
⊢ d ∈ t | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
hac : a ≠ c
h : a = d
⊢ a ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
hac : a ≠ c
h : a = d
⊢ d ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | exact ha | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
hac : a ≠ c
h : a = d
⊢ a ∈ t | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht : Set.ncard t ≤ 2
c d : α
hc : c ∉ t
hd : d ∉ t
hcd : ¬c = d
hac : a ≠ c
h : a = d
⊢ a ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | suffices (t \ {a, b}).Nonempty by
obtain ⟨c, h⟩ := this
simp only [Set.mem_diff, Set.mem_insert_iff, Set.mem_singleton_iff, not_or] at h
use c | case neg.inr
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
⊢ ∃ c ∈ t, c ≠ a ∧ c ≠ b | case neg.inr
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
⊢ Set.Nonempty (t \ {a, b}) | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.inr
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
⊢ ∃ c ∈ t, c ≠ a ∧ c ≠ b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [Set.nonempty_diff] | case neg.inr
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
⊢ Set.Nonempty (t \ {a, b}) | case neg.inr
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
⊢ ¬t ⊆ {a, b} | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.inr
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
⊢ Set.Nonempty (t \ {a, b})
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | intro ht | case neg.inr
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
⊢ ¬t ⊆ {a, b} | case neg.inr
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
ht : t ⊆ {a, b}
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.inr
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
⊢ ¬t ⊆ {a, b}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [gt_iff_lt, ← not_le] at ht' | case neg.inr
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
ht : t ⊆ {a, b}
⊢ False | case neg.inr
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : ¬Set.ncard t ≤ 2
ht : t ⊆ {a, b}
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.inr
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
ht : t ⊆ {a, b}
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | apply ht' | case neg.inr
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : ¬Set.ncard t ≤ 2
ht : t ⊆ {a, b}
⊢ False | case neg.inr
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : ¬Set.ncard t ≤ 2
ht : t ⊆ {a, b}
⊢ Set.ncard t ≤ 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.inr
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : ¬Set.ncard t ≤ 2
ht : t ⊆ {a, b}
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | convert Set.ncard_le_ncard ht | case neg.inr
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : ¬Set.ncard t ≤ 2
ht : t ⊆ {a, b}
⊢ Set.ncard t ≤ 2 | case h.e'_4
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : ¬Set.ncard t ≤ 2
ht : t ⊆ {a, b}
⊢ 2 = Set.ncard {a, b} | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.inr
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : ¬Set.ncard t ≤ 2
ht : t ⊆ {a, b}
⊢ Set.ncard t ≤ 2
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [(Set.ncard_pair hab).symm] | case h.e'_4
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : ¬Set.ncard t ≤ 2
ht : t ⊆ {a, b}
⊢ 2 = Set.ncard {a, b} | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_4
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : ¬Set.ncard t ≤ 2
ht : t ⊆ {a, b}
⊢ 2 = Set.ncard {a, b}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | obtain ⟨c, hc, hca, hcb⟩ := this | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
this : ∃ c ∈ t, c ≠ a ∧ c ≠ b
⊢ ∃ g ∈ stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α, g • a = b | case intro.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ ∃ g ∈ stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α, g • a = b | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
this : ∃ c ∈ t, c ≠ a ∧ c ≠ b
⊢ ∃ g ∈ stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α, g • a = b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | use Equiv.swap a c * Equiv.swap a b | case intro.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ ∃ g ∈ stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α, g • a = b | case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ Equiv.swap a c * Equiv.swap a b ∈ stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α ∧
(Equiv.swap a c * Equiv.swap a b) • a = b | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ ∃ g ∈ stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α, g • a = b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | constructor | case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ Equiv.swap a c * Equiv.swap a b ∈ stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α ∧
(Equiv.swap a c * Equiv.swap a b) • a = b | case h.left
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ Equiv.swap a c * Equiv.swap a b ∈ stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α
case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ (Equiv.swap a c * Equiv.swap a b) • a = b | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ Equiv.swap a c * Equiv.swap a b ∈ stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α ∧
(Equiv.swap a c * Equiv.swap a b) • a = b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | simp only [Subgroup.mem_inf] | case h.left
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ Equiv.swap a c * Equiv.swap a b ∈ stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α | case h.left
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ Equiv.swap a c * Equiv.swap a b ∈ stabilizer (Equiv.Perm α) t ∧ Equiv.swap a c * Equiv.swap a b ∈ alternatingGroup α | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ Equiv.swap a c * Equiv.swap a b ∈ stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | constructor | case h.left
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ Equiv.swap a c * Equiv.swap a b ∈ stabilizer (Equiv.Perm α) t ∧ Equiv.swap a c * Equiv.swap a b ∈ alternatingGroup α | case h.left.left
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ Equiv.swap a c * Equiv.swap a b ∈ stabilizer (Equiv.Perm α) t
case h.left.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ Equiv.swap a c * Equiv.swap a b ∈ alternatingGroup α | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ Equiv.swap a c * Equiv.swap a b ∈ stabilizer (Equiv.Perm α) t ∧ Equiv.swap a c * Equiv.swap a b ∈ alternatingGroup α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [mem_stabilizer_of_finite_iff_smul_le _ _ t.toFinite] | case h.left.left
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ Equiv.swap a c * Equiv.swap a b ∈ stabilizer (Equiv.Perm α) t | case h.left.left
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ (Equiv.swap a c * Equiv.swap a b) • t ⊆ t | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.left
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ Equiv.swap a c * Equiv.swap a b ∈ stabilizer (Equiv.Perm α) t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rintro _ ⟨x, hx, rfl⟩ | case h.left.left
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ (Equiv.swap a c * Equiv.swap a b) • t ⊆ t | case h.left.left.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
⊢ (fun x => (Equiv.swap a c * Equiv.swap a b) • x) x ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.left
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ (Equiv.swap a c * Equiv.swap a b) • t ⊆ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | simp only [Equiv.Perm.smul_def, Equiv.Perm.coe_mul, Function.comp_apply] | case h.left.left.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
⊢ (fun x => (Equiv.swap a c * Equiv.swap a b) • x) x ∈ t | case h.left.left.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
⊢ (Equiv.swap a c) ((Equiv.swap a b) x) ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.left.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
⊢ (fun x => (Equiv.swap a c * Equiv.swap a b) • x) x ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | by_cases hxa : x = a | case h.left.left.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
⊢ (Equiv.swap a c) ((Equiv.swap a b) x) ∈ t | case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x = a
⊢ (Equiv.swap a c) ((Equiv.swap a b) x) ∈ t
case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : ¬x = a
⊢ (Equiv.swap a c) ((Equiv.swap a b) x) ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.left.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
⊢ (Equiv.swap a c) ((Equiv.swap a b) x) ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [hxa, Equiv.swap_apply_left] | case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x = a
⊢ (Equiv.swap a c) ((Equiv.swap a b) x) ∈ t | case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x = a
⊢ (Equiv.swap a c) b ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x = a
⊢ (Equiv.swap a c) ((Equiv.swap a b) x) ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [Equiv.swap_apply_of_ne_of_ne hab.symm hcb.symm] | case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x = a
⊢ (Equiv.swap a c) b ∈ t | case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x = a
⊢ b ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x = a
⊢ (Equiv.swap a c) b ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | exact hb | case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x = a
⊢ b ∈ t | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x = a
⊢ b ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [← Ne.def] at hxa | case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : ¬x = a
⊢ (Equiv.swap a c) ((Equiv.swap a b) x) ∈ t | case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
⊢ (Equiv.swap a c) ((Equiv.swap a b) x) ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : ¬x = a
⊢ (Equiv.swap a c) ((Equiv.swap a b) x) ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | by_cases hxb : x = b | case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
⊢ (Equiv.swap a c) ((Equiv.swap a b) x) ∈ t | case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x = b
⊢ (Equiv.swap a c) ((Equiv.swap a b) x) ∈ t
case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : ¬x = b
⊢ (Equiv.swap a c) ((Equiv.swap a b) x) ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
⊢ (Equiv.swap a c) ((Equiv.swap a b) x) ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [hxb, Equiv.swap_apply_right, Equiv.swap_apply_left] | case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x = b
⊢ (Equiv.swap a c) ((Equiv.swap a b) x) ∈ t | case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x = b
⊢ c ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x = b
⊢ (Equiv.swap a c) ((Equiv.swap a b) x) ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | exact hc | case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x = b
⊢ c ∈ t | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x = b
⊢ c ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [← Ne.def] at hxb | case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : ¬x = b
⊢ (Equiv.swap a c) ((Equiv.swap a b) x) ∈ t | case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x ≠ b
⊢ (Equiv.swap a c) ((Equiv.swap a b) x) ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : ¬x = b
⊢ (Equiv.swap a c) ((Equiv.swap a b) x) ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [Equiv.swap_apply_of_ne_of_ne hxa hxb] | case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x ≠ b
⊢ (Equiv.swap a c) ((Equiv.swap a b) x) ∈ t | case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x ≠ b
⊢ (Equiv.swap a c) x ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x ≠ b
⊢ (Equiv.swap a c) ((Equiv.swap a b) x) ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | by_cases hxc : x = c | case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x ≠ b
⊢ (Equiv.swap a c) x ∈ t | case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x ≠ b
hxc : x = c
⊢ (Equiv.swap a c) x ∈ t
case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x ≠ b
hxc : ¬x = c
⊢ (Equiv.swap a c) x ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x ≠ b
⊢ (Equiv.swap a c) x ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [hxc, Equiv.swap_apply_right] | case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x ≠ b
hxc : x = c
⊢ (Equiv.swap a c) x ∈ t | case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x ≠ b
hxc : x = c
⊢ a ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x ≠ b
hxc : x = c
⊢ (Equiv.swap a c) x ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | exact ha | case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x ≠ b
hxc : x = c
⊢ a ∈ t | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x ≠ b
hxc : x = c
⊢ a ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [← Ne.def] at hxc | case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x ≠ b
hxc : ¬x = c
⊢ (Equiv.swap a c) x ∈ t | case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x ≠ b
hxc : x ≠ c
⊢ (Equiv.swap a c) x ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x ≠ b
hxc : ¬x = c
⊢ (Equiv.swap a c) x ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [Equiv.swap_apply_of_ne_of_ne hxa hxc] | case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x ≠ b
hxc : x ≠ c
⊢ (Equiv.swap a c) x ∈ t | case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x ≠ b
hxc : x ≠ c
⊢ x ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x ≠ b
hxc : x ≠ c
⊢ (Equiv.swap a c) x ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | exact hx | case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x ≠ b
hxc : x ≠ c
⊢ x ∈ t | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
x : α
hx : x ∈ t
hxa : x ≠ a
hxb : x ≠ b
hxc : x ≠ c
⊢ x ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | simp only [Equiv.Perm.mem_alternatingGroup, Equiv.Perm.sign_mul] | case h.left.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ Equiv.swap a c * Equiv.swap a b ∈ alternatingGroup α | case h.left.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ Equiv.Perm.sign (Equiv.swap a c) * Equiv.Perm.sign (Equiv.swap a b) = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ Equiv.swap a c * Equiv.swap a b ∈ alternatingGroup α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [Equiv.Perm.sign_swap hab] | case h.left.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ Equiv.Perm.sign (Equiv.swap a c) * Equiv.Perm.sign (Equiv.swap a b) = 1 | case h.left.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ Equiv.Perm.sign (Equiv.swap a c) * -1 = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ Equiv.Perm.sign (Equiv.swap a c) * Equiv.Perm.sign (Equiv.swap a b) = 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [Equiv.Perm.sign_swap (Ne.symm hca)] | case h.left.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ Equiv.Perm.sign (Equiv.swap a c) * -1 = 1 | case h.left.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ -1 * -1 = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ Equiv.Perm.sign (Equiv.swap a c) * -1 = 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | simp only [Int.units_mul_self] | case h.left.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ -1 * -1 = 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ -1 * -1 = 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | simp only [Equiv.Perm.smul_def, Equiv.Perm.coe_mul, Function.comp_apply] | case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ (Equiv.swap a c * Equiv.swap a b) • a = b | case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ (Equiv.swap a c) ((Equiv.swap a b) a) = b | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ (Equiv.swap a c * Equiv.swap a b) • a = b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [Equiv.swap_apply_left] | case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ (Equiv.swap a c) ((Equiv.swap a b) a) = b | case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ (Equiv.swap a c) b = b | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ (Equiv.swap a c) ((Equiv.swap a b) a) = b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | rw [Equiv.swap_apply_of_ne_of_ne (Ne.symm hab) (Ne.symm hcb)] | case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ (Equiv.swap a c) b = b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
hc : c ∈ t
hca : c ≠ a
hcb : c ≠ b
⊢ (Equiv.swap a c) b = b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | obtain ⟨c, h⟩ := this | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
this : Set.Nonempty (t \ {a, b})
⊢ ∃ c ∈ t, c ≠ a ∧ c ≠ b | case intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
h : c ∈ t \ {a, b}
⊢ ∃ c ∈ t, c ≠ a ∧ c ≠ b | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
this : Set.Nonempty (t \ {a, b})
⊢ ∃ c ∈ t, c ≠ a ∧ c ≠ b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | simp only [Set.mem_diff, Set.mem_insert_iff, Set.mem_singleton_iff, not_or] at h | case intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
h : c ∈ t \ {a, b}
⊢ ∃ c ∈ t, c ≠ a ∧ c ≠ b | case intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
h : c ∈ t ∧ ¬c = a ∧ ¬c = b
⊢ ∃ c ∈ t, c ≠ a ∧ c ≠ b | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
h : c ∈ t \ {a, b}
⊢ ∃ c ∈ t, c ≠ a ∧ c ≠ b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in | [153, 1] | [238, 37] | use c | case intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
h : c ∈ t ∧ ¬c = a ∧ ¬c = b
⊢ ∃ c ∈ t, c ≠ a ∧ c ≠ b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
t : Set α
a : α
ha : a ∈ t
b : α
hb : b ∈ t
hab : a ≠ b
ht' : Set.ncard t > 2
c : α
h : c ∈ t ∧ ¬c = a ∧ ¬c = b
⊢ ∃ c ∈ t, c ≠ a ∧ c ≠ b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in' | [241, 1] | [249, 10] | intro a ha b hb | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
G : Subgroup (Equiv.Perm α)
t : Set α
hGt : stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α ≤ G
⊢ ∀ a ∈ t, ∀ b ∈ t, ∃ g, g • a = b | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
G : Subgroup (Equiv.Perm α)
t : Set α
hGt : stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α ≤ G
a : α
ha : a ∈ t
b : α
hb : b ∈ t
⊢ ∃ g, g • a = b | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
G : Subgroup (Equiv.Perm α)
t : Set α
hGt : stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α ≤ G
⊢ ∀ a ∈ t, ∀ b ∈ t, ∃ g, g • a = b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in' | [241, 1] | [249, 10] | obtain ⟨g, hg, H⟩ := moves_in hα t a ha b hb | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
G : Subgroup (Equiv.Perm α)
t : Set α
hGt : stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α ≤ G
a : α
ha : a ∈ t
b : α
hb : b ∈ t
⊢ ∃ g, g • a = b | case intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
G : Subgroup (Equiv.Perm α)
t : Set α
hGt : stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α ≤ G
a : α
ha : a ∈ t
b : α
hb : b ∈ t
g : Equiv.Perm α
hg : g ∈ stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α
H : g • a = b
⊢ ∃ g, g • a = b | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
G : Subgroup (Equiv.Perm α)
t : Set α
hGt : stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α ≤ G
a : α
ha : a ∈ t
b : α
hb : b ∈ t
⊢ ∃ g, g • a = b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in' | [241, 1] | [249, 10] | use! g | case intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
G : Subgroup (Equiv.Perm α)
t : Set α
hGt : stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α ≤ G
a : α
ha : a ∈ t
b : α
hb : b ∈ t
g : Equiv.Perm α
hg : g ∈ stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α
H : g • a = b
⊢ ∃ g, g • a = b | case property
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
G : Subgroup (Equiv.Perm α)
t : Set α
hGt : stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α ≤ G
a : α
ha : a ∈ t
b : α
hb : b ∈ t
g : Equiv.Perm α
hg : g ∈ stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α
H : g • a = b
⊢ g ∈ G
case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
G : Subgroup (Equiv.Perm α)
t : Set α
hGt : stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α ≤ G
a : α
ha : a ∈ t
b : α
hb : b ∈ t
g : Equiv.Perm α
hg : g ∈ stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α
H : g • a = b
⊢ { val := g, property := ?property } • a = b | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
G : Subgroup (Equiv.Perm α)
t : Set α
hGt : stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α ≤ G
a : α
ha : a ∈ t
b : α
hb : b ∈ t
g : Equiv.Perm α
hg : g ∈ stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α
H : g • a = b
⊢ ∃ g, g • a = b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in' | [241, 1] | [249, 10] | exact hGt hg | case property
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
G : Subgroup (Equiv.Perm α)
t : Set α
hGt : stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α ≤ G
a : α
ha : a ∈ t
b : α
hb : b ∈ t
g : Equiv.Perm α
hg : g ∈ stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α
H : g • a = b
⊢ g ∈ G
case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
G : Subgroup (Equiv.Perm α)
t : Set α
hGt : stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α ≤ G
a : α
ha : a ∈ t
b : α
hb : b ∈ t
g : Equiv.Perm α
hg : g ∈ stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α
H : g • a = b
⊢ { val := g, property := ?property } • a = b | case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
G : Subgroup (Equiv.Perm α)
t : Set α
hGt : stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α ≤ G
a : α
ha : a ∈ t
b : α
hb : b ∈ t
g : Equiv.Perm α
hg : g ∈ stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α
H : g • a = b
⊢ { val := g, property := ⋯ } • a = b | Please generate a tactic in lean4 to solve the state.
STATE:
case property
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
G : Subgroup (Equiv.Perm α)
t : Set α
hGt : stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α ≤ G
a : α
ha : a ∈ t
b : α
hb : b ∈ t
g : Equiv.Perm α
hg : g ∈ stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α
H : g • a = b
⊢ g ∈ G
case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
G : Subgroup (Equiv.Perm α)
t : Set α
hGt : stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α ≤ G
a : α
ha : a ∈ t
b : α
hb : b ∈ t
g : Equiv.Perm α
hg : g ∈ stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α
H : g • a = b
⊢ { val := g, property := ?property } • a = b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.moves_in' | [241, 1] | [249, 10] | exact H | case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
G : Subgroup (Equiv.Perm α)
t : Set α
hGt : stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α ≤ G
a : α
ha : a ∈ t
b : α
hb : b ∈ t
g : Equiv.Perm α
hg : g ∈ stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α
H : g • a = b
⊢ { val := g, property := ⋯ } • a = b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
hα : 4 ≤ Fintype.card α
G : Subgroup (Equiv.Perm α)
t : Set α
hGt : stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α ≤ G
a : α
ha : a ∈ t
b : α
hb : b ∈ t
g : Equiv.Perm α
hg : g ∈ stabilizer (Equiv.Perm α) t ⊓ alternatingGroup α
H : g • a = b
⊢ { val := g, property := ⋯ } • a = b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer' | [255, 1] | [271, 40] | rw [Set.two_lt_ncard_iff] at hs | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
hs : 2 < Set.ncard s
⊢ ∃ g, Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
hs : ∃ a b c, a ∈ s ∧ b ∈ s ∧ c ∈ s ∧ a ≠ b ∧ a ≠ c ∧ b ≠ c
⊢ ∃ g, Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
hs : 2 < Set.ncard s
⊢ ∃ g, Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer' | [255, 1] | [271, 40] | obtain ⟨a, b, c, ha, hb, hc, hab, hac, hbc⟩ := hs | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
hs : ∃ a b c, a ∈ s ∧ b ∈ s ∧ c ∈ s ∧ a ≠ b ∧ a ≠ c ∧ b ≠ c
⊢ ∃ g, Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s | case intro.intro.intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
⊢ ∃ g, Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
hs : ∃ a b c, a ∈ s ∧ b ∈ s ∧ c ∈ s ∧ a ≠ b ∧ a ≠ c ∧ b ≠ c
⊢ ∃ g, Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer' | [255, 1] | [271, 40] | use Equiv.swap a b * Equiv.swap a c | case intro.intro.intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
⊢ ∃ g, Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s | case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
⊢ Equiv.Perm.IsThreeCycle (Equiv.swap a b * Equiv.swap a c) ∧
Equiv.swap a b * Equiv.swap a c ∈ stabilizer (Equiv.Perm α) s | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
⊢ ∃ g, Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer' | [255, 1] | [271, 40] | constructor | case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
⊢ Equiv.Perm.IsThreeCycle (Equiv.swap a b * Equiv.swap a c) ∧
Equiv.swap a b * Equiv.swap a c ∈ stabilizer (Equiv.Perm α) s | case h.left
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
⊢ Equiv.Perm.IsThreeCycle (Equiv.swap a b * Equiv.swap a c)
case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
⊢ Equiv.swap a b * Equiv.swap a c ∈ stabilizer (Equiv.Perm α) s | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
⊢ Equiv.Perm.IsThreeCycle (Equiv.swap a b * Equiv.swap a c) ∧
Equiv.swap a b * Equiv.swap a c ∈ stabilizer (Equiv.Perm α) s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer' | [255, 1] | [271, 40] | apply Equiv.Perm.isThreeCycle_swap_mul_swap_same hab hac hbc | case h.left
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
⊢ Equiv.Perm.IsThreeCycle (Equiv.swap a b * Equiv.swap a c)
case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
⊢ Equiv.swap a b * Equiv.swap a c ∈ stabilizer (Equiv.Perm α) s | case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
⊢ Equiv.swap a b * Equiv.swap a c ∈ stabilizer (Equiv.Perm α) s | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
⊢ Equiv.Perm.IsThreeCycle (Equiv.swap a b * Equiv.swap a c)
case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
⊢ Equiv.swap a b * Equiv.swap a c ∈ stabilizer (Equiv.Perm α) s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer' | [255, 1] | [271, 40] | rw [← stabilizer_compl] | case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
⊢ Equiv.swap a b * Equiv.swap a c ∈ stabilizer (Equiv.Perm α) s | case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
⊢ Equiv.swap a b * Equiv.swap a c ∈ stabilizer (Equiv.Perm α) sᶜ | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
⊢ Equiv.swap a b * Equiv.swap a c ∈ stabilizer (Equiv.Perm α) s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer' | [255, 1] | [271, 40] | rw [mem_stabilizer_of_finite_iff_smul_le _ _ sᶜ.toFinite] | case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
⊢ Equiv.swap a b * Equiv.swap a c ∈ stabilizer (Equiv.Perm α) sᶜ | case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
⊢ (Equiv.swap a b * Equiv.swap a c) • sᶜ ⊆ sᶜ | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
⊢ Equiv.swap a b * Equiv.swap a c ∈ stabilizer (Equiv.Perm α) sᶜ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer' | [255, 1] | [271, 40] | rintro _ ⟨x, hx, rfl⟩ | case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
⊢ (Equiv.swap a b * Equiv.swap a c) • sᶜ ⊆ sᶜ | case h.right.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
x : α
hx : x ∈ sᶜ
⊢ (fun x => (Equiv.swap a b * Equiv.swap a c) • x) x ∈ sᶜ | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
⊢ (Equiv.swap a b * Equiv.swap a c) • sᶜ ⊆ sᶜ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer' | [255, 1] | [271, 40] | simp only [Equiv.Perm.smul_def, Equiv.Perm.coe_mul, Function.comp_apply] | case h.right.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
x : α
hx : x ∈ sᶜ
⊢ (fun x => (Equiv.swap a b * Equiv.swap a c) • x) x ∈ sᶜ | case h.right.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
x : α
hx : x ∈ sᶜ
⊢ (Equiv.swap a b) ((Equiv.swap a c) x) ∈ sᶜ | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
x : α
hx : x ∈ sᶜ
⊢ (fun x => (Equiv.swap a b * Equiv.swap a c) • x) x ∈ sᶜ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer' | [255, 1] | [271, 40] | rw [Set.mem_compl_iff] at hx | case h.right.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
x : α
hx : x ∈ sᶜ
⊢ (Equiv.swap a b) ((Equiv.swap a c) x) ∈ sᶜ | case h.right.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
x : α
hx : x ∉ s
⊢ (Equiv.swap a b) ((Equiv.swap a c) x) ∈ sᶜ | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
x : α
hx : x ∈ sᶜ
⊢ (Equiv.swap a b) ((Equiv.swap a c) x) ∈ sᶜ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer' | [255, 1] | [271, 40] | suffices h : ∀ u ∈ s, x ≠ u by
rw [Equiv.swap_apply_of_ne_of_ne (h a ha) (h c hc)]
rw [Equiv.swap_apply_of_ne_of_ne (h a ha) (h b hb)]
exact hx | case h.right.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
x : α
hx : x ∉ s
⊢ (Equiv.swap a b) ((Equiv.swap a c) x) ∈ sᶜ | case h.right.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
x : α
hx : x ∉ s
⊢ ∀ u ∈ s, x ≠ u | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
x : α
hx : x ∉ s
⊢ (Equiv.swap a b) ((Equiv.swap a c) x) ∈ sᶜ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer' | [255, 1] | [271, 40] | intro u hu | case h.right.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
x : α
hx : x ∉ s
⊢ ∀ u ∈ s, x ≠ u | case h.right.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
x : α
hx : x ∉ s
u : α
hu : u ∈ s
⊢ x ≠ u | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
x : α
hx : x ∉ s
⊢ ∀ u ∈ s, x ≠ u
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer' | [255, 1] | [271, 40] | exact ne_of_prop_ne hx hu | case h.right.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
x : α
hx : x ∉ s
u : α
hu : u ∈ s
⊢ x ≠ u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
x : α
hx : x ∉ s
u : α
hu : u ∈ s
⊢ x ≠ u
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer' | [255, 1] | [271, 40] | rw [Equiv.swap_apply_of_ne_of_ne (h a ha) (h c hc)] | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
x : α
hx : x ∉ s
h : ∀ u ∈ s, x ≠ u
⊢ (Equiv.swap a b) ((Equiv.swap a c) x) ∈ sᶜ | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
x : α
hx : x ∉ s
h : ∀ u ∈ s, x ≠ u
⊢ (Equiv.swap a b) x ∈ sᶜ | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
x : α
hx : x ∉ s
h : ∀ u ∈ s, x ≠ u
⊢ (Equiv.swap a b) ((Equiv.swap a c) x) ∈ sᶜ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer' | [255, 1] | [271, 40] | rw [Equiv.swap_apply_of_ne_of_ne (h a ha) (h b hb)] | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
x : α
hx : x ∉ s
h : ∀ u ∈ s, x ≠ u
⊢ (Equiv.swap a b) x ∈ sᶜ | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
x : α
hx : x ∉ s
h : ∀ u ∈ s, x ≠ u
⊢ x ∈ sᶜ | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
x : α
hx : x ∉ s
h : ∀ u ∈ s, x ≠ u
⊢ (Equiv.swap a b) x ∈ sᶜ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer' | [255, 1] | [271, 40] | exact hx | α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
x : α
hx : x ∉ s
h : ∀ u ∈ s, x ≠ u
⊢ x ∈ sᶜ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
s : Set α
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
x : α
hx : x ∉ s
h : ∀ u ∈ s, x ≠ u
⊢ x ∈ sᶜ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer | [275, 1] | [287, 32] | cases' Nat.lt_or_ge 2 (Set.ncard s) with hs hs | α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : 4 < Fintype.card α
⊢ ∃ g, Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s | case inl
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : 4 < Fintype.card α
hs : 2 < Set.ncard s
⊢ ∃ g, Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s
case inr
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : 4 < Fintype.card α
hs : 2 ≥ Set.ncard s
⊢ ∃ g, Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : 4 < Fintype.card α
⊢ ∃ g, Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer | [275, 1] | [287, 32] | exact has_three_cycle_of_stabilizer' s hs | case inl
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : 4 < Fintype.card α
hs : 2 < Set.ncard s
⊢ ∃ g, Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : 4 < Fintype.card α
hs : 2 < Set.ncard s
⊢ ∃ g, Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer | [275, 1] | [287, 32] | suffices hs' : _ by
obtain ⟨g, hg, hg'⟩ := has_three_cycle_of_stabilizer' (sᶜ) hs'
use g
rw [stabilizer_compl] at hg'
exact ⟨hg, hg'⟩ | case inr
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : 4 < Fintype.card α
hs : 2 ≥ Set.ncard s
⊢ ∃ g, Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s | case inr
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : 4 < Fintype.card α
hs : 2 ≥ Set.ncard s
⊢ 2 < Set.ncard sᶜ | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : 4 < Fintype.card α
hs : 2 ≥ Set.ncard s
⊢ ∃ g, Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer | [275, 1] | [287, 32] | rw [lt_iff_not_le] at hα ⊢ | case inr
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : 4 < Fintype.card α
hs : 2 ≥ Set.ncard s
⊢ 2 < Set.ncard sᶜ | case inr
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : ¬Fintype.card α ≤ 4
hs : 2 ≥ Set.ncard s
⊢ ¬Set.ncard sᶜ ≤ 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : 4 < Fintype.card α
hs : 2 ≥ Set.ncard s
⊢ 2 < Set.ncard sᶜ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer | [275, 1] | [287, 32] | intro hs' | case inr
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : ¬Fintype.card α ≤ 4
hs : 2 ≥ Set.ncard s
⊢ ¬Set.ncard sᶜ ≤ 2 | case inr
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : ¬Fintype.card α ≤ 4
hs : 2 ≥ Set.ncard s
hs' : Set.ncard sᶜ ≤ 2
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : ¬Fintype.card α ≤ 4
hs : 2 ≥ Set.ncard s
⊢ ¬Set.ncard sᶜ ≤ 2
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer | [275, 1] | [287, 32] | apply hα | case inr
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : ¬Fintype.card α ≤ 4
hs : 2 ≥ Set.ncard s
hs' : Set.ncard sᶜ ≤ 2
⊢ False | case inr
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : ¬Fintype.card α ≤ 4
hs : 2 ≥ Set.ncard s
hs' : Set.ncard sᶜ ≤ 2
⊢ Fintype.card α ≤ 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : ¬Fintype.card α ≤ 4
hs : 2 ≥ Set.ncard s
hs' : Set.ncard sᶜ ≤ 2
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer | [275, 1] | [287, 32] | rw [← Nat.card_eq_fintype_card, ← Set.ncard_add_ncard_compl s] | case inr
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : ¬Fintype.card α ≤ 4
hs : 2 ≥ Set.ncard s
hs' : Set.ncard sᶜ ≤ 2
⊢ Fintype.card α ≤ 4 | case inr
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : ¬Fintype.card α ≤ 4
hs : 2 ≥ Set.ncard s
hs' : Set.ncard sᶜ ≤ 2
⊢ Set.ncard s + Set.ncard sᶜ ≤ 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : ¬Fintype.card α ≤ 4
hs : 2 ≥ Set.ncard s
hs' : Set.ncard sᶜ ≤ 2
⊢ Fintype.card α ≤ 4
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer | [275, 1] | [287, 32] | exact Nat.add_le_add hs hs' | case inr
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : ¬Fintype.card α ≤ 4
hs : 2 ≥ Set.ncard s
hs' : Set.ncard sᶜ ≤ 2
⊢ Set.ncard s + Set.ncard sᶜ ≤ 4 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : ¬Fintype.card α ≤ 4
hs : 2 ≥ Set.ncard s
hs' : Set.ncard sᶜ ≤ 2
⊢ Set.ncard s + Set.ncard sᶜ ≤ 4
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer | [275, 1] | [287, 32] | obtain ⟨g, hg, hg'⟩ := has_three_cycle_of_stabilizer' (sᶜ) hs' | α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : 4 < Fintype.card α
hs : 2 ≥ Set.ncard s
hs' : ?m.50651
⊢ ∃ g, Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s | case intro.intro
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : 4 < Fintype.card α
hs : 2 ≥ Set.ncard s
hs' : 2 < Set.ncard sᶜ
g : Equiv.Perm α
hg : Equiv.Perm.IsThreeCycle g
hg' : g ∈ stabilizer (Equiv.Perm α) sᶜ
⊢ ∃ g, Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : 4 < Fintype.card α
hs : 2 ≥ Set.ncard s
hs' : ?m.50651
⊢ ∃ g, Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer | [275, 1] | [287, 32] | use g | case intro.intro
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : 4 < Fintype.card α
hs : 2 ≥ Set.ncard s
hs' : 2 < Set.ncard sᶜ
g : Equiv.Perm α
hg : Equiv.Perm.IsThreeCycle g
hg' : g ∈ stabilizer (Equiv.Perm α) sᶜ
⊢ ∃ g, Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s | case h
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : 4 < Fintype.card α
hs : 2 ≥ Set.ncard s
hs' : 2 < Set.ncard sᶜ
g : Equiv.Perm α
hg : Equiv.Perm.IsThreeCycle g
hg' : g ∈ stabilizer (Equiv.Perm α) sᶜ
⊢ Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : 4 < Fintype.card α
hs : 2 ≥ Set.ncard s
hs' : 2 < Set.ncard sᶜ
g : Equiv.Perm α
hg : Equiv.Perm.IsThreeCycle g
hg' : g ∈ stabilizer (Equiv.Perm α) sᶜ
⊢ ∃ g, Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer | [275, 1] | [287, 32] | rw [stabilizer_compl] at hg' | case h
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : 4 < Fintype.card α
hs : 2 ≥ Set.ncard s
hs' : 2 < Set.ncard sᶜ
g : Equiv.Perm α
hg : Equiv.Perm.IsThreeCycle g
hg' : g ∈ stabilizer (Equiv.Perm α) sᶜ
⊢ Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s | case h
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : 4 < Fintype.card α
hs : 2 ≥ Set.ncard s
hs' : 2 < Set.ncard sᶜ
g : Equiv.Perm α
hg : Equiv.Perm.IsThreeCycle g
hg' : g ∈ stabilizer (Equiv.Perm α) s
⊢ Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : 4 < Fintype.card α
hs : 2 ≥ Set.ncard s
hs' : 2 < Set.ncard sᶜ
g : Equiv.Perm α
hg : Equiv.Perm.IsThreeCycle g
hg' : g ∈ stabilizer (Equiv.Perm α) sᶜ
⊢ Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/AlternatingMaximal.lean | alternatingGroup.has_three_cycle_of_stabilizer | [275, 1] | [287, 32] | exact ⟨hg, hg'⟩ | case h
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : 4 < Fintype.card α
hs : 2 ≥ Set.ncard s
hs' : 2 < Set.ncard sᶜ
g : Equiv.Perm α
hg : Equiv.Perm.IsThreeCycle g
hg' : g ∈ stabilizer (Equiv.Perm α) s
⊢ Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
inst✝² : Fintype α
inst✝¹ inst✝ : DecidableEq α
s : Set α
hα : 4 < Fintype.card α
hs : 2 ≥ Set.ncard s
hs' : 2 < Set.ncard sᶜ
g : Equiv.Perm α
hg : Equiv.Perm.IsThreeCycle g
hg' : g ∈ stabilizer (Equiv.Perm α) s
⊢ Equiv.Perm.IsThreeCycle g ∧ g ∈ stabilizer (Equiv.Perm α) s
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.