url stringclasses 147
values | commit stringclasses 147
values | file_path stringlengths 7 101 | full_name stringlengths 1 94 | start stringlengths 6 10 | end stringlengths 6 11 | tactic stringlengths 1 11.2k | state_before stringlengths 3 2.09M | state_after stringlengths 6 2.09M | input stringlengths 73 2.09M |
|---|---|---|---|---|---|---|---|---|---|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.exists_smul_of_last_eq | [436, 1] | [460, 14] | use g | case intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
⊢ ∃ g x1,
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a) ∧
g • x (Fin.last n) = a | case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
⊢ ∃ x1,
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a) ∧
g • x (Fin.last n) = a | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
⊢ ∃ g x1,
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a) ∧
g • x (Fin.last n) = a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.exists_smul_of_last_eq | [436, 1] | [460, 14] | have zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a := by
rintro ⟨i, hi⟩
rw [SubMulAction.mem_ofStabilizer_iff]
rw [← hgx]
simp only [Fin.castSucc_mk, ne_eq, smul_left_cancel_iff, EmbeddingLike.apply_eq_iff_eq, Fin.mk.injEq]
exact Fin.ne_of_lt hi | case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
⊢ ∃ x1,
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a) ∧
g • x (Fin.last n) = a | case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
⊢ ∃ x1,
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a) ∧
g • x (Fin.last n) = a | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
⊢ ∃ x1,
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a) ∧
g • x (Fin.last n) = a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.exists_smul_of_last_eq | [436, 1] | [460, 14] | use {
toFun := fun i => ⟨g • x i, (by
simp
exact zgx i)⟩
inj' := fun i j ↦ by
simp only [Fin.coe_eq_castSucc, Subtype.mk.injEq, smul_left_cancel_iff,
EmbeddingLike.apply_eq_iff_eq, Fin.castSucc_inj, imp_self] } | case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
⊢ ∃ x1,
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a) ∧
g • x (Fin.last n) = a | case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
⊢ Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x) =
Function.Embedding.trans { toFun := fun i => { val := g • x ↑↑i, property := ⋯ }, inj' := ⋯ }
(subtype fun x => x ∈ SubMulAction.ofStabilizer M a) ∧
g • x (Fin.last n) = a | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
⊢ ∃ x1,
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a) ∧
g • x (Fin.last n) = a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.exists_smul_of_last_eq | [436, 1] | [460, 14] | constructor | case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
⊢ Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x) =
Function.Embedding.trans { toFun := fun i => { val := g • x ↑↑i, property := ⋯ }, inj' := ⋯ }
(subtype fun x => x ∈ SubMulAction.ofStabilizer M a) ∧
g • x (Fin.last n) = a | case h.left
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
⊢ Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x) =
Function.Embedding.trans { toFun := fun i => { val := g • x ↑↑i, property := ⋯ }, inj' := ⋯ }
(subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
case h.right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
⊢ g • x (Fin.last n) = a | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
⊢ Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x) =
Function.Embedding.trans { toFun := fun i => { val := g • x ↑↑i, property := ⋯ }, inj' := ⋯ }
(subtype fun x => x ∈ SubMulAction.ofStabilizer M a) ∧
g • x (Fin.last n) = a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.exists_smul_of_last_eq | [436, 1] | [460, 14] | rintro ⟨i, hi⟩ | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
⊢ ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a | case mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
i : ℕ
hi : i < n
⊢ g • x (Fin.castSucc { val := i, isLt := hi }) ∈ SubMulAction.ofStabilizer M a | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
⊢ ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.exists_smul_of_last_eq | [436, 1] | [460, 14] | rw [SubMulAction.mem_ofStabilizer_iff] | case mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
i : ℕ
hi : i < n
⊢ g • x (Fin.castSucc { val := i, isLt := hi }) ∈ SubMulAction.ofStabilizer M a | case mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
i : ℕ
hi : i < n
⊢ g • x (Fin.castSucc { val := i, isLt := hi }) ≠ a | Please generate a tactic in lean4 to solve the state.
STATE:
case mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
i : ℕ
hi : i < n
⊢ g • x (Fin.castSucc { val := i, isLt := hi }) ∈ SubMulAction.ofStabilizer M a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.exists_smul_of_last_eq | [436, 1] | [460, 14] | rw [← hgx] | case mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
i : ℕ
hi : i < n
⊢ g • x (Fin.castSucc { val := i, isLt := hi }) ≠ a | case mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
i : ℕ
hi : i < n
⊢ g • x (Fin.castSucc { val := i, isLt := hi }) ≠ g • x (Fin.last n) | Please generate a tactic in lean4 to solve the state.
STATE:
case mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
i : ℕ
hi : i < n
⊢ g • x (Fin.castSucc { val := i, isLt := hi }) ≠ a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.exists_smul_of_last_eq | [436, 1] | [460, 14] | simp only [Fin.castSucc_mk, ne_eq, smul_left_cancel_iff, EmbeddingLike.apply_eq_iff_eq, Fin.mk.injEq] | case mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
i : ℕ
hi : i < n
⊢ g • x (Fin.castSucc { val := i, isLt := hi }) ≠ g • x (Fin.last n) | case mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
i : ℕ
hi : i < n
⊢ ¬{ val := i, isLt := ⋯ } = Fin.last n | Please generate a tactic in lean4 to solve the state.
STATE:
case mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
i : ℕ
hi : i < n
⊢ g • x (Fin.castSucc { val := i, isLt := hi }) ≠ g • x (Fin.last n)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.exists_smul_of_last_eq | [436, 1] | [460, 14] | exact Fin.ne_of_lt hi | case mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
i : ℕ
hi : i < n
⊢ ¬{ val := i, isLt := ⋯ } = Fin.last n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
i : ℕ
hi : i < n
⊢ ¬{ val := i, isLt := ⋯ } = Fin.last n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.exists_smul_of_last_eq | [436, 1] | [460, 14] | simp | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
i : Fin n
⊢ g • x ↑↑i ∈ SubMulAction.ofStabilizer M a | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
i : Fin n
⊢ g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
i : Fin n
⊢ g • x ↑↑i ∈ SubMulAction.ofStabilizer M a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.exists_smul_of_last_eq | [436, 1] | [460, 14] | exact zgx i | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
i : Fin n
⊢ g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
i : Fin n
⊢ g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.exists_smul_of_last_eq | [436, 1] | [460, 14] | simp only [Fin.coe_eq_castSucc, Subtype.mk.injEq, smul_left_cancel_iff,
EmbeddingLike.apply_eq_iff_eq, Fin.castSucc_inj, imp_self] | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
i j : Fin n
⊢ (fun i => { val := g • x ↑↑i, property := ⋯ }) i = (fun i => { val := g • x ↑↑i, property := ⋯ }) j → i = j | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
i j : Fin n
⊢ (fun i => { val := g • x ↑↑i, property := ⋯ }) i = (fun i => { val := g • x ↑↑i, property := ⋯ }) j → i = j
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.exists_smul_of_last_eq | [436, 1] | [460, 14] | ext i | case h.left
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
⊢ Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x) =
Function.Embedding.trans { toFun := fun i => { val := g • x ↑↑i, property := ⋯ }, inj' := ⋯ }
(subtype fun x => x ∈ SubMulAction.ofStabilizer M a) | case h.left.h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
i : Fin n
⊢ (Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x)) i =
(Function.Embedding.trans { toFun := fun i => { val := g • x ↑↑i, property := ⋯ }, inj' := ⋯ }
(subtype fun x => x ∈ SubMulAction.ofStabilizer M a))
i | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
⊢ Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x) =
Function.Embedding.trans { toFun := fun i => { val := g • x ↑↑i, property := ⋯ }, inj' := ⋯ }
(subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.exists_smul_of_last_eq | [436, 1] | [460, 14] | simp | case h.left.h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
i : Fin n
⊢ (Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x)) i =
(Function.Embedding.trans { toFun := fun i => { val := g • x ↑↑i, property := ⋯ }, inj' := ⋯ }
(subtype fun x => x ∈ SubMulAction.ofStabilizer M a))
i | case h.left.h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
i : Fin n
⊢ Fin.castLE ⋯ i = Fin.castSucc i | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
i : Fin n
⊢ (Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x)) i =
(Function.Embedding.trans { toFun := fun i => { val := g • x ↑↑i, property := ⋯ }, inj' := ⋯ }
(subtype fun x => x ∈ SubMulAction.ofStabilizer M a))
i
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.exists_smul_of_last_eq | [436, 1] | [460, 14] | rfl | case h.left.h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
i : Fin n
⊢ Fin.castLE ⋯ i = Fin.castSucc i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
i : Fin n
⊢ Fin.castLE ⋯ i = Fin.castSucc i
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.exists_smul_of_last_eq | [436, 1] | [460, 14] | exact hgx | case h.right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
⊢ g • x (Fin.last n) = a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
zgx : ∀ (i : Fin n), g • x (Fin.castSucc i) ∈ SubMulAction.ofStabilizer M a
⊢ g • x (Fin.last n) = a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | constructor | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
⊢ IsMultiplyPretransitive M α (succ n) ↔
∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n | case mp
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
⊢ IsMultiplyPretransitive M α (succ n) →
∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
case mpr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
⊢ (∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n) →
IsMultiplyPretransitive M α (succ n) | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
⊢ IsMultiplyPretransitive M α (succ n) ↔
∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | intro hn a | case mp
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
⊢ IsMultiplyPretransitive M α (succ n) →
∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n | case mp
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
⊢ IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
⊢ IsMultiplyPretransitive M α (succ n) →
∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | let hn_eq := hn.exists_smul_eq | case mp
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
⊢ IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n | case mp
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
⊢ IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | apply IsPretransitive.mk | case mp
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n | case mp.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | intro x y | case mp.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y | case mp.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | obtain ⟨x', hx', hx'a⟩ := exists_extends_with_last_eq M a x | case mp.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
⊢ ∃ g, g • x = y | case mp.exists_smul_eq.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | obtain ⟨y', hy', hy'a⟩ := exists_extends_with_last_eq M a y | case mp.exists_smul_eq.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
⊢ ∃ g, g • x = y | case mp.exists_smul_eq.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.exists_smul_eq.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | obtain ⟨g, hg'⟩ := hn_eq x' y' | case mp.exists_smul_eq.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
⊢ ∃ g, g • x = y | case mp.exists_smul_eq.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.exists_smul_eq.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | have hg : g ∈ stabilizer M a := by
rw [mem_stabilizer_iff]
conv_lhs => rw [← hx'a]
rw [← hy'a, ← hg', smul_apply] | case mp.exists_smul_eq.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
⊢ ∃ g, g • x = y | case mp.exists_smul_eq.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.exists_smul_eq.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | use ⟨g, hg⟩ | case mp.exists_smul_eq.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
⊢ ∃ g, g • x = y | case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
⊢ { val := g, property := hg } • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.exists_smul_eq.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | ext ⟨i, hi⟩ | case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
⊢ { val := g, property := hg } • x = y | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
⊢ ↑(({ val := g, property := hg } • x) { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi }) | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
⊢ { val := g, property := hg } • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | simp only [smul_apply, SubMulAction.val_smul_of_tower] | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
⊢ ↑(({ val := g, property := hg } • x) { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi }) | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi }) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
⊢ ↑(({ val := g, property := hg } • x) { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi })
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | rw [← Function.Embedding.ext_iff] at hx' hy' | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi }) | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
∀ (x_1 : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') x_1 =
(Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }) x_1
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
∀ (x : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') x =
(Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }) x
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi }) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi })
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | specialize hx' ⟨i, hi⟩ | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
∀ (x_1 : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') x_1 =
(Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }) x_1
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
∀ (x : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') x =
(Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }) x
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi }) | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
∀ (x : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') x =
(Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }) x
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
hx' :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') { val := i, isLt := hi } =
(Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }) { val := i, isLt := hi }
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi }) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
∀ (x_1 : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') x_1 =
(Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }) x_1
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
∀ (x : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') x =
(Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }) x
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi })
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | specialize hy' ⟨i, hi⟩ | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
∀ (x : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') x =
(Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }) x
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
hx' :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') { val := i, isLt := hi } =
(Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }) { val := i, isLt := hi }
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi }) | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
hx' :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') { val := i, isLt := hi } =
(Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }) { val := i, isLt := hi }
hy' :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') { val := i, isLt := hi } =
(Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }) { val := i, isLt := hi }
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi }) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
∀ (x : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') x =
(Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }) x
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
hx' :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') { val := i, isLt := hi } =
(Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }) { val := i, isLt := hi }
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi })
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | simp only [trans_apply, RelEmbedding.coe_toEmbedding, Fin.castLE_mk, id.def, coeFn_mk]
at hx' hy' | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
hx' :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') { val := i, isLt := hi } =
(Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }) { val := i, isLt := hi }
hy' :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') { val := i, isLt := hi } =
(Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }) { val := i, isLt := hi }
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi }) | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
hx' : x' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) = ↑(x { val := i, isLt := hi })
hy' : y' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi })
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi }) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
hx' :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') { val := i, isLt := hi } =
(Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }) { val := i, isLt := hi }
hy' :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') { val := i, isLt := hi } =
(Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }) { val := i, isLt := hi }
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi })
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | rw [← hx', ← hy', ← hg'] | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
hx' : x' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) = ↑(x { val := i, isLt := hi })
hy' : y' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi })
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi }) | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
hx' : x' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) = ↑(x { val := i, isLt := hi })
hy' : y' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi })
⊢ { val := g, property := hg } • x' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) =
(g • x') ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
hx' : x' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) = ↑(x { val := i, isLt := hi })
hy' : y' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi })
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi })
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | rfl | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
hx' : x' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) = ↑(x { val := i, isLt := hi })
hy' : y' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi })
⊢ { val := g, property := hg } • x' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) =
(g • x') ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
hx' : x' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) = ↑(x { val := i, isLt := hi })
hy' : y' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi })
⊢ { val := g, property := hg } • x' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) =
(g • x') ((Fin.castLEEmb ⋯) { val := i, isLt := hi })
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | rw [mem_stabilizer_iff] | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
⊢ g ∈ stabilizer M a | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
⊢ g • a = a | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
⊢ g ∈ stabilizer M a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | conv_lhs => rw [← hx'a] | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
⊢ g • a = a | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
⊢ g • x' { val := n, isLt := ⋯ } = a | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
⊢ g • a = a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | rw [← hy'a, ← hg', smul_apply] | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
⊢ g • x' { val := n, isLt := ⋯ } = a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : IsMultiplyPretransitive M α (succ n)
a : α
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
⊢ g • x' { val := n, isLt := ⋯ } = a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | intro hn | case mpr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
⊢ (∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n) →
IsMultiplyPretransitive M α (succ n) | case mpr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
⊢ IsMultiplyPretransitive M α (succ n) | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
⊢ (∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n) →
IsMultiplyPretransitive M α (succ n)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | apply IsPretransitive.mk | case mpr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
⊢ IsMultiplyPretransitive M α (succ n) | case mpr.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
⊢ ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
⊢ IsMultiplyPretransitive M α (succ n)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | intro x | case mpr.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
⊢ ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y | case mpr.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
⊢ ∀ (y : Fin (succ n) ↪ α), ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
⊢ ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | let a := x ⟨n, lt_add_one n⟩ | case mpr.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
⊢ ∀ (y : Fin (succ n) ↪ α), ∃ g, g • x = y | case mpr.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
⊢ ∀ (y : Fin (succ n) ↪ α), ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
⊢ ∀ (y : Fin (succ n) ↪ α), ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | obtain ⟨gx, x1, hgx, hga⟩ := exists_smul_of_last_eq M a x | case mpr.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
⊢ ∀ (y : Fin (succ n) ↪ α), ∃ g, g • x = y | case mpr.exists_smul_eq.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
⊢ ∀ (y : Fin (succ n) ↪ α), ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
⊢ ∀ (y : Fin (succ n) ↪ α), ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | intro y | case mpr.exists_smul_eq.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
⊢ ∀ (y : Fin (succ n) ↪ α), ∃ g, g • x = y | case mpr.exists_smul_eq.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.exists_smul_eq.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
⊢ ∀ (y : Fin (succ n) ↪ α), ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | obtain ⟨gy, y1, hgy, hgb⟩ := exists_smul_of_last_eq M a y | case mpr.exists_smul_eq.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
⊢ ∃ g, g • x = y | case mpr.exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.exists_smul_eq.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | let hna_eq := (hn a).exists_smul_eq | case mpr.exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
⊢ ∃ g, g • x = y | case mpr.exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | obtain ⟨g, hg⟩ := hna_eq x1 y1 | case mpr.exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∃ g, g • x = y | case mpr.exists_smul_eq.intro.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | use gy⁻¹ * g * gx | case mpr.exists_smul_eq.intro.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
⊢ ∃ g, g • x = y | case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
⊢ (gy⁻¹ * ↑g * gx) • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.exists_smul_eq.intro.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | ext ⟨i, hi⟩ | case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
⊢ (gy⁻¹ * ↑g * gx) • x = y | case h.h.mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
⊢ ((gy⁻¹ * ↑g * gx) • x) { val := i, isLt := hi } = y { val := i, isLt := hi } | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
⊢ (gy⁻¹ * ↑g * gx) • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | rw [mul_smul] | case h.h.mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
⊢ ((gy⁻¹ * ↑g * gx) • x) { val := i, isLt := hi } = y { val := i, isLt := hi } | case h.h.mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
⊢ ((gy⁻¹ * ↑g) • gx • x) { val := i, isLt := hi } = y { val := i, isLt := hi } | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
⊢ ((gy⁻¹ * ↑g * gx) • x) { val := i, isLt := hi } = y { val := i, isLt := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | simp only [smul_apply] | case h.h.mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
⊢ ((gy⁻¹ * ↑g) • gx • x) { val := i, isLt := hi } = y { val := i, isLt := hi } | case h.h.mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi } | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
⊢ ((gy⁻¹ * ↑g) • gx • x) { val := i, isLt := hi } = y { val := i, isLt := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | cases' lt_or_eq_of_le (le_of_lt_succ hi) with hi' hi' | case h.h.mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi } | case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
hi' : i < n
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi }
case h.h.mk.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
hi' : i = n
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi } | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | rw [← Function.Embedding.ext_iff] at hgx hgy hg | case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
hi' : i < n
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi } | case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
∀ (x_1 : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x)) x_1 =
(Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) x_1
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
∀ (x : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y)) x =
(Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) x
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : ∀ (x : Fin n), (g • x1) x = y1 x
i : ℕ
hi : i < succ n
hi' : i < n
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi } | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
hi' : i < n
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | specialize hgx ⟨i, hi'⟩ | case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
∀ (x_1 : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x)) x_1 =
(Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) x_1
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
∀ (x : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y)) x =
(Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) x
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : ∀ (x : Fin n), (g • x1) x = y1 x
i : ℕ
hi : i < succ n
hi' : i < n
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi } | case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
∀ (x : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y)) x =
(Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) x
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : ∀ (x : Fin n), (g • x1) x = y1 x
i : ℕ
hi : i < succ n
hi' : i < n
hgx :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x)) { val := i, isLt := hi' } =
(Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) { val := i, isLt := hi' }
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi } | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
∀ (x_1 : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x)) x_1 =
(Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) x_1
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
∀ (x : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y)) x =
(Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) x
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : ∀ (x : Fin n), (g • x1) x = y1 x
i : ℕ
hi : i < succ n
hi' : i < n
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | specialize hgy ⟨i, hi'⟩ | case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
∀ (x : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y)) x =
(Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) x
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : ∀ (x : Fin n), (g • x1) x = y1 x
i : ℕ
hi : i < succ n
hi' : i < n
hgx :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x)) { val := i, isLt := hi' } =
(Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) { val := i, isLt := hi' }
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi } | case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : ∀ (x : Fin n), (g • x1) x = y1 x
i : ℕ
hi : i < succ n
hi' : i < n
hgx :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x)) { val := i, isLt := hi' } =
(Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) { val := i, isLt := hi' }
hgy :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y)) { val := i, isLt := hi' } =
(Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) { val := i, isLt := hi' }
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi } | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
∀ (x : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y)) x =
(Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) x
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : ∀ (x : Fin n), (g • x1) x = y1 x
i : ℕ
hi : i < succ n
hi' : i < n
hgx :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x)) { val := i, isLt := hi' } =
(Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) { val := i, isLt := hi' }
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | specialize hg ⟨i, hi'⟩ | case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : ∀ (x : Fin n), (g • x1) x = y1 x
i : ℕ
hi : i < succ n
hi' : i < n
hgx :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x)) { val := i, isLt := hi' } =
(Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) { val := i, isLt := hi' }
hgy :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y)) { val := i, isLt := hi' } =
(Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) { val := i, isLt := hi' }
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi } | case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
i : ℕ
hi : i < succ n
hi' : i < n
hgx :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x)) { val := i, isLt := hi' } =
(Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) { val := i, isLt := hi' }
hgy :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y)) { val := i, isLt := hi' } =
(Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) { val := i, isLt := hi' }
hg : (g • x1) { val := i, isLt := hi' } = y1 { val := i, isLt := hi' }
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi } | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : ∀ (x : Fin n), (g • x1) x = y1 x
i : ℕ
hi : i < succ n
hi' : i < n
hgx :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x)) { val := i, isLt := hi' } =
(Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) { val := i, isLt := hi' }
hgy :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y)) { val := i, isLt := hi' } =
(Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) { val := i, isLt := hi' }
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | simp only [Fin.castLEEmb_toEmbedding, trans_apply, coeFn_mk, Fin.castLE_mk,
smul_apply, zero_eq, coe_subtype] at hgx hgy hg | case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
i : ℕ
hi : i < succ n
hi' : i < n
hgx :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x)) { val := i, isLt := hi' } =
(Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) { val := i, isLt := hi' }
hgy :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y)) { val := i, isLt := hi' } =
(Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) { val := i, isLt := hi' }
hg : (g • x1) { val := i, isLt := hi' } = y1 { val := i, isLt := hi' }
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi } | case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
i : ℕ
hi : i < succ n
hi' : i < n
hgx : gx • x { val := i, isLt := ⋯ } = ↑(x1 { val := i, isLt := hi' })
hgy : gy • y { val := i, isLt := ⋯ } = ↑(y1 { val := i, isLt := hi' })
hg : g • x1 { val := i, isLt := hi' } = y1 { val := i, isLt := hi' }
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi } | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
i : ℕ
hi : i < succ n
hi' : i < n
hgx :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x)) { val := i, isLt := hi' } =
(Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) { val := i, isLt := hi' }
hgy :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y)) { val := i, isLt := hi' } =
(Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) { val := i, isLt := hi' }
hg : (g • x1) { val := i, isLt := hi' } = y1 { val := i, isLt := hi' }
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | rw [hgx, mul_smul, inv_smul_eq_iff, hgy, ← hg] | case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
i : ℕ
hi : i < succ n
hi' : i < n
hgx : gx • x { val := i, isLt := ⋯ } = ↑(x1 { val := i, isLt := hi' })
hgy : gy • y { val := i, isLt := ⋯ } = ↑(y1 { val := i, isLt := hi' })
hg : g • x1 { val := i, isLt := hi' } = y1 { val := i, isLt := hi' }
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi } | case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
i : ℕ
hi : i < succ n
hi' : i < n
hgx : gx • x { val := i, isLt := ⋯ } = ↑(x1 { val := i, isLt := hi' })
hgy : gy • y { val := i, isLt := ⋯ } = ↑(y1 { val := i, isLt := hi' })
hg : g • x1 { val := i, isLt := hi' } = y1 { val := i, isLt := hi' }
⊢ ↑g • ↑(x1 { val := i, isLt := hi' }) = ↑(g • x1 { val := i, isLt := hi' }) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
i : ℕ
hi : i < succ n
hi' : i < n
hgx : gx • x { val := i, isLt := ⋯ } = ↑(x1 { val := i, isLt := hi' })
hgy : gy • y { val := i, isLt := ⋯ } = ↑(y1 { val := i, isLt := hi' })
hg : g • x1 { val := i, isLt := hi' } = y1 { val := i, isLt := hi' }
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | rfl | case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
i : ℕ
hi : i < succ n
hi' : i < n
hgx : gx • x { val := i, isLt := ⋯ } = ↑(x1 { val := i, isLt := hi' })
hgy : gy • y { val := i, isLt := ⋯ } = ↑(y1 { val := i, isLt := hi' })
hg : g • x1 { val := i, isLt := hi' } = y1 { val := i, isLt := hi' }
⊢ ↑g • ↑(x1 { val := i, isLt := hi' }) = ↑(g • x1 { val := i, isLt := hi' }) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
i : ℕ
hi : i < succ n
hi' : i < n
hgx : gx • x { val := i, isLt := ⋯ } = ↑(x1 { val := i, isLt := hi' })
hgy : gy • y { val := i, isLt := ⋯ } = ↑(y1 { val := i, isLt := hi' })
hg : g • x1 { val := i, isLt := hi' } = y1 { val := i, isLt := hi' }
⊢ ↑g • ↑(x1 { val := i, isLt := hi' }) = ↑(g • x1 { val := i, isLt := hi' })
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | simp only [hi'] | case h.h.mk.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
hi' : i = n
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi } | case h.h.mk.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
hi' : i = n
⊢ (gy⁻¹ * ↑g) • gx • x { val := n, isLt := ⋯ } = y { val := n, isLt := ⋯ } | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
hi' : i = n
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | dsimp [Fin.last] at hga hgb | case h.h.mk.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
hi' : i = n
⊢ (gy⁻¹ * ↑g) • gx • x { val := n, isLt := ⋯ } = y { val := n, isLt := ⋯ } | case h.h.mk.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x { val := n, isLt := ⋯ } = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y { val := n, isLt := ⋯ } = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
hi' : i = n
⊢ (gy⁻¹ * ↑g) • gx • x { val := n, isLt := ⋯ } = y { val := n, isLt := ⋯ } | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
hi' : i = n
⊢ (gy⁻¹ * ↑g) • gx • x { val := n, isLt := ⋯ } = y { val := n, isLt := ⋯ }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | rw [hga, mul_smul, inv_smul_eq_iff, hgb] | case h.h.mk.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x { val := n, isLt := ⋯ } = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y { val := n, isLt := ⋯ } = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
hi' : i = n
⊢ (gy⁻¹ * ↑g) • gx • x { val := n, isLt := ⋯ } = y { val := n, isLt := ⋯ } | case h.h.mk.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x { val := n, isLt := ⋯ } = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y { val := n, isLt := ⋯ } = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
hi' : i = n
⊢ ↑g • a = a | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x { val := n, isLt := ⋯ } = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y { val := n, isLt := ⋯ } = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
hi' : i = n
⊢ (gy⁻¹ * ↑g) • gx • x { val := n, isLt := ⋯ } = y { val := n, isLt := ⋯ }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | rw [← mem_stabilizer_iff] | case h.h.mk.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x { val := n, isLt := ⋯ } = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y { val := n, isLt := ⋯ } = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
hi' : i = n
⊢ ↑g • a = a | case h.h.mk.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x { val := n, isLt := ⋯ } = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y { val := n, isLt := ⋯ } = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
hi' : i = n
⊢ ↑g ∈ stabilizer M a | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x { val := n, isLt := ⋯ } = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y { val := n, isLt := ⋯ } = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
hi' : i = n
⊢ ↑g • a = a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive' | [466, 1] | [558, 57] | exact SetLike.coe_mem g | case h.h.mk.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x { val := n, isLt := ⋯ } = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y { val := n, isLt := ⋯ } = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
hi' : i = n
⊢ ↑g ∈ stabilizer M a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
hn : ∀ (a : α), IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
a : α := x { val := n, isLt := ⋯ }
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x { val := n, isLt := ⋯ } = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y { val := n, isLt := ⋯ } = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
hi' : i = n
⊢ ↑g ∈ stabilizer M a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | constructor | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
⊢ IsMultiplyPretransitive M α (succ n) ↔
IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n | case mp
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
⊢ IsMultiplyPretransitive M α (succ n) →
IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
case mpr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
⊢ IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n →
IsMultiplyPretransitive M α (succ n) | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
⊢ IsMultiplyPretransitive M α (succ n) ↔
IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | intro hn | case mp
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
⊢ IsMultiplyPretransitive M α (succ n) →
IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n | case mp
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
⊢ IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
⊢ IsMultiplyPretransitive M α (succ n) →
IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | let hn_eq := hn.exists_smul_eq | case mp
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
⊢ IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n | case mp
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
⊢ IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | apply IsPretransitive.mk | case mp
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n | case mp.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | intro x y | case mp.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y | case mp.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | obtain ⟨x', hx', hx'a⟩ := exists_extends_with_last_eq M a x | case mp.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
⊢ ∃ g, g • x = y | case mp.exists_smul_eq.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | obtain ⟨y', hy', hy'a⟩ := exists_extends_with_last_eq M a y | case mp.exists_smul_eq.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
⊢ ∃ g, g • x = y | case mp.exists_smul_eq.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.exists_smul_eq.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | obtain ⟨g, hg'⟩ := hn_eq x' y' | case mp.exists_smul_eq.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
⊢ ∃ g, g • x = y | case mp.exists_smul_eq.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.exists_smul_eq.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | have hg : g ∈ stabilizer M a := by
rw [mem_stabilizer_iff]
conv_lhs => rw [← hx'a]
rw [← hy'a, ← hg', smul_apply] | case mp.exists_smul_eq.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
⊢ ∃ g, g • x = y | case mp.exists_smul_eq.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.exists_smul_eq.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | use ⟨g, hg⟩ | case mp.exists_smul_eq.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
⊢ ∃ g, g • x = y | case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
⊢ { val := g, property := hg } • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.exists_smul_eq.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | ext ⟨i, hi⟩ | case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
⊢ { val := g, property := hg } • x = y | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
⊢ ↑(({ val := g, property := hg } • x) { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi }) | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
⊢ { val := g, property := hg } • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | simp only [smul_apply, SubMulAction.val_smul_of_tower] | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
⊢ ↑(({ val := g, property := hg } • x) { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi }) | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi }) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
⊢ ↑(({ val := g, property := hg } • x) { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi })
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | rw [← Function.Embedding.ext_iff] at hx' hy' | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi }) | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
∀ (x_1 : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') x_1 =
(Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }) x_1
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
∀ (x : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') x =
(Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }) x
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi }) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi })
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | specialize hx' ⟨i, hi⟩ | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
∀ (x_1 : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') x_1 =
(Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }) x_1
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
∀ (x : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') x =
(Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }) x
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi }) | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
∀ (x : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') x =
(Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }) x
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
hx' :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') { val := i, isLt := hi } =
(Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }) { val := i, isLt := hi }
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi }) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
∀ (x_1 : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') x_1 =
(Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }) x_1
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
∀ (x : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') x =
(Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }) x
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi })
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | specialize hy' ⟨i, hi⟩ | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
∀ (x : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') x =
(Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }) x
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
hx' :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') { val := i, isLt := hi } =
(Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }) { val := i, isLt := hi }
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi }) | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
hx' :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') { val := i, isLt := hi } =
(Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }) { val := i, isLt := hi }
hy' :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') { val := i, isLt := hi } =
(Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }) { val := i, isLt := hi }
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi }) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
∀ (x : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') x =
(Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }) x
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
hx' :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') { val := i, isLt := hi } =
(Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }) { val := i, isLt := hi }
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi })
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | simp only [trans_apply, RelEmbedding.coe_toEmbedding, Fin.castLE_mk, id.def, coeFn_mk] at hx' hy' | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
hx' :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') { val := i, isLt := hi } =
(Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }) { val := i, isLt := hi }
hy' :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') { val := i, isLt := hi } =
(Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }) { val := i, isLt := hi }
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi }) | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
hx' : x' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) = ↑(x { val := i, isLt := hi })
hy' : y' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi })
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi }) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
hx' :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') { val := i, isLt := hi } =
(Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }) { val := i, isLt := hi }
hy' :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') { val := i, isLt := hi } =
(Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }) { val := i, isLt := hi }
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi })
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | rw [← hx', ← hy', ← hg'] | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
hx' : x' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) = ↑(x { val := i, isLt := hi })
hy' : y' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi })
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi }) | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
hx' : x' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) = ↑(x { val := i, isLt := hi })
hy' : y' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi })
⊢ { val := g, property := hg } • x' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) =
(g • x') ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
hx' : x' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) = ↑(x { val := i, isLt := hi })
hy' : y' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi })
⊢ { val := g, property := hg } • ↑(x { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi })
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | rfl | case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
hx' : x' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) = ↑(x { val := i, isLt := hi })
hy' : y' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi })
⊢ { val := g, property := hg } • x' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) =
(g • x') ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
hg : g ∈ stabilizer M a
i : ℕ
hi : i < n
hx' : x' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) = ↑(x { val := i, isLt := hi })
hy' : y' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) = ↑(y { val := i, isLt := hi })
⊢ { val := g, property := hg } • x' ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) =
(g • x') ((Fin.castLEEmb ⋯) { val := i, isLt := hi })
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | rw [mem_stabilizer_iff] | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
⊢ g ∈ stabilizer M a | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
⊢ g • a = a | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
⊢ g ∈ stabilizer M a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | conv_lhs => rw [← hx'a] | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
⊢ g • a = a | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
⊢ g • x' { val := n, isLt := ⋯ } = a | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
⊢ g • a = a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | rw [← hy'a, ← hg', smul_apply] | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
⊢ g • x' { val := n, isLt := ⋯ } = a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive M α (succ n)
hn_eq : ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x' : Fin (succ n) ↪ α
hx' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' =
Function.Embedding.trans x { toFun := fun u => id ↑u, inj' := ⋯ }
hx'a : x' { val := n, isLt := ⋯ } = a
y' : Fin (succ n) ↪ α
hy' :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' =
Function.Embedding.trans y { toFun := fun u => id ↑u, inj' := ⋯ }
hy'a : y' { val := n, isLt := ⋯ } = a
g : M
hg' : g • x' = y'
⊢ g • x' { val := n, isLt := ⋯ } = a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | intro hn | case mpr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
⊢ IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n →
IsMultiplyPretransitive M α (succ n) | case mpr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
⊢ IsMultiplyPretransitive M α (succ n) | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
⊢ IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n →
IsMultiplyPretransitive M α (succ n)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | apply IsPretransitive.mk | case mpr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
⊢ IsMultiplyPretransitive M α (succ n) | case mpr.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
⊢ ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
⊢ IsMultiplyPretransitive M α (succ n)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | intro x | case mpr.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
⊢ ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y | case mpr.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
⊢ ∀ (y : Fin (succ n) ↪ α), ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
⊢ ∀ (x y : Fin (succ n) ↪ α), ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | obtain ⟨gx, x1, hgx, hga⟩ := exists_smul_of_last_eq M a x | case mpr.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
⊢ ∀ (y : Fin (succ n) ↪ α), ∃ g, g • x = y | case mpr.exists_smul_eq.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
⊢ ∀ (y : Fin (succ n) ↪ α), ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.exists_smul_eq
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
⊢ ∀ (y : Fin (succ n) ↪ α), ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | intro y | case mpr.exists_smul_eq.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
⊢ ∀ (y : Fin (succ n) ↪ α), ∃ g, g • x = y | case mpr.exists_smul_eq.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.exists_smul_eq.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
⊢ ∀ (y : Fin (succ n) ↪ α), ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | obtain ⟨gy, y1, hgy, hgb⟩ := exists_smul_of_last_eq M a y | case mpr.exists_smul_eq.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
⊢ ∃ g, g • x = y | case mpr.exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.exists_smul_eq.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | let hna_eq := hn.exists_smul_eq | case mpr.exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
⊢ ∃ g, g • x = y | case mpr.exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | obtain ⟨g, hg⟩ := hna_eq x1 y1 | case mpr.exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∃ g, g • x = y | case mpr.exists_smul_eq.intro.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | use gy⁻¹ * g * gx | case mpr.exists_smul_eq.intro.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
⊢ ∃ g, g • x = y | case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
⊢ (gy⁻¹ * ↑g * gx) • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.exists_smul_eq.intro.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | ext ⟨i, hi⟩ | case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
⊢ (gy⁻¹ * ↑g * gx) • x = y | case h.h.mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
⊢ ((gy⁻¹ * ↑g * gx) • x) { val := i, isLt := hi } = y { val := i, isLt := hi } | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
⊢ (gy⁻¹ * ↑g * gx) • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | rw [mul_smul] | case h.h.mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
⊢ ((gy⁻¹ * ↑g * gx) • x) { val := i, isLt := hi } = y { val := i, isLt := hi } | case h.h.mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
⊢ ((gy⁻¹ * ↑g) • gx • x) { val := i, isLt := hi } = y { val := i, isLt := hi } | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
⊢ ((gy⁻¹ * ↑g * gx) • x) { val := i, isLt := hi } = y { val := i, isLt := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | simp only [smul_apply] | case h.h.mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
⊢ ((gy⁻¹ * ↑g) • gx • x) { val := i, isLt := hi } = y { val := i, isLt := hi } | case h.h.mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi } | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
⊢ ((gy⁻¹ * ↑g) • gx • x) { val := i, isLt := hi } = y { val := i, isLt := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | cases' lt_or_eq_of_le (le_of_lt_succ hi) with hi' hi' | case h.h.mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi } | case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
hi' : i < n
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi }
case h.h.mk.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
hi' : i = n
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi } | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | rw [← Function.Embedding.ext_iff] at hgx hgy hg | case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
hi' : i < n
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi } | case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
∀ (x_1 : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x)) x_1 =
(Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) x_1
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
∀ (x : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y)) x =
(Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) x
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : ∀ (x : Fin n), (g • x1) x = y1 x
i : ℕ
hi : i < succ n
hi' : i < n
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi } | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y) =
Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : g • x1 = y1
i : ℕ
hi : i < succ n
hi' : i < n
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | specialize hgx ⟨i, hi'⟩ | case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
∀ (x_1 : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x)) x_1 =
(Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) x_1
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
∀ (x : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y)) x =
(Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) x
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : ∀ (x : Fin n), (g • x1) x = y1 x
i : ℕ
hi : i < succ n
hi' : i < n
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi } | case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
∀ (x : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y)) x =
(Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) x
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : ∀ (x : Fin n), (g • x1) x = y1 x
i : ℕ
hi : i < succ n
hi' : i < n
hgx :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x)) { val := i, isLt := hi' } =
(Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) { val := i, isLt := hi' }
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi } | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgx :
∀ (x_1 : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x)) x_1 =
(Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) x_1
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
∀ (x : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y)) x =
(Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) x
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : ∀ (x : Fin n), (g • x1) x = y1 x
i : ℕ
hi : i < succ n
hi' : i < n
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 57] | specialize hgy ⟨i, hi'⟩ | case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
∀ (x : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y)) x =
(Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) x
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : ∀ (x : Fin n), (g • x1) x = y1 x
i : ℕ
hi : i < succ n
hi' : i < n
hgx :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x)) { val := i, isLt := hi' } =
(Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) { val := i, isLt := hi' }
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi } | case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : ∀ (x : Fin n), (g • x1) x = y1 x
i : ℕ
hi : i < succ n
hi' : i < n
hgx :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x)) { val := i, isLt := hi' } =
(Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) { val := i, isLt := hi' }
hgy :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y)) { val := i, isLt := hi' } =
(Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) { val := i, isLt := hi' }
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi } | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
hn : IsMultiplyPretransitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
x : Fin (succ n) ↪ α
gx : M
x1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hga : gx • x (Fin.last n) = a
y : Fin (succ n) ↪ α
gy : M
y1 : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
hgy :
∀ (x : Fin n),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gy • y)) x =
(Function.Embedding.trans y1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) x
hgb : gy • y (Fin.last n) = a
hna_eq : ∀ (x y : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : ↥(stabilizer M a)
hg : ∀ (x : Fin n), (g • x1) x = y1 x
i : ℕ
hi : i < succ n
hi' : i < n
hgx :
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (gx • x)) { val := i, isLt := hi' } =
(Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)) { val := i, isLt := hi' }
⊢ (gy⁻¹ * ↑g) • gx • x { val := i, isLt := hi } = y { val := i, isLt := hi }
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.