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.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 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 : ℕ
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 } | 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)
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 : ℕ
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 }
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, smul_apply,
Function.Embedding.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 : ℕ
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)
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 : ℕ
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)
i : ℕ
hi : i < succ n
hi' : i < n
hgx : gx • x ((Fin.castLEEmb ⋯) { val := i, isLt := hi' }) = ↑(x1 { val := i, isLt := hi' })
hgy : gy • y ((Fin.castLEEmb ⋯) { val := i, isLt := hi' }) = ↑(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 : ℕ
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)
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 | [564, 1] | [631, 57] | dsimp only [Fin.castLEEmb_apply, Fin.castLE_mk] at hgx hgy | 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)
i : ℕ
hi : i < succ n
hi' : i < n
hgx : gx • x ((Fin.castLEEmb ⋯) { val := i, isLt := hi' }) = ↑(x1 { val := i, isLt := hi' })
hgy : gy • y ((Fin.castLEEmb ⋯) { val := i, isLt := hi' }) = ↑(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 : ℕ
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)
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 : ℕ
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)
i : ℕ
hi : i < succ n
hi' : i < n
hgx : gx • x ((Fin.castLEEmb ⋯) { val := i, isLt := hi' }) = ↑(x1 { val := i, isLt := hi' })
hgy : gy • y ((Fin.castLEEmb ⋯) { val := i, isLt := hi' }) = ↑(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 | [564, 1] | [631, 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 : ℕ
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)
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 : ℕ
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)
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 : ℕ
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)
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 | [564, 1] | [631, 57] | rfl | 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)
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 : ℕ
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)
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 | [564, 1] | [631, 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 : ℕ
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 := 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 : ℕ
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] | dsimp only [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 : ℕ
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 := 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 : ℕ
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 { 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 : ℕ
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 := n, isLt := ⋯ } = y { val := n, isLt := ⋯ }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer.isMultiplyPretransitive | [564, 1] | [631, 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 : ℕ
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 { 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 : ℕ
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 { 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 : ℕ
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 { 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 | [564, 1] | [631, 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 : ℕ
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 { 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 : ℕ
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 { 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 : ℕ
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 { 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 | [564, 1] | [631, 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 : ℕ
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 { 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 : ℕ
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 { 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.remaining_transitivity | [636, 1] | [681, 38] | have hs : PartENat.card s = s.ncard := by
rw [s.ncard_eq_toFinset_card, PartENat.card_eq_coe_nat_card, Set.Nat.card_coe_set_eq, PartENat.natCast_inj, s.ncard_eq_toFinset_card] | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
⊢ IsMultiplyPretransitive (↥(fixingSubgroup M s)) (↥(SubMulAction.ofFixingSubgroup M s)) m | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
⊢ IsMultiplyPretransitive (↥(fixingSubgroup M s)) (↥(SubMulAction.ofFixingSubgroup M s)) m | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
⊢ IsMultiplyPretransitive (↥(fixingSubgroup M s)) (↥(SubMulAction.ofFixingSubgroup M s)) m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | apply IsPretransitive.mk | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
⊢ IsMultiplyPretransitive (↥(fixingSubgroup M s)) (↥(SubMulAction.ofFixingSubgroup M s)) m | case exists_smul_eq
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
⊢ ∀ (x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)), ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
⊢ IsMultiplyPretransitive (↥(fixingSubgroup M s)) (↥(SubMulAction.ofFixingSubgroup M s)) m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | intro x y | case exists_smul_eq
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
⊢ ∀ (x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)), ∃ g, g • x = y | case exists_smul_eq
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
⊢ ∀ (x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)), ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | obtain ⟨z⟩ := equiv_fin_of_partENat_card_eq hs | case exists_smul_eq
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
⊢ ∃ g, g • x = y | case exists_smul_eq.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | obtain ⟨x', hx'1, hx'2⟩ := may_extend_with' z.toEmbedding hmn x | case exists_smul_eq.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
⊢ ∃ g, g • x = y | case exists_smul_eq.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | obtain ⟨y' : Fin n ↪ α, hy'1, hy'2⟩ := may_extend_with' z.toEmbedding hmn y | case exists_smul_eq.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
⊢ ∃ g, g • x = y | case exists_smul_eq.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | obtain ⟨g, hg⟩ := h.exists_smul_eq x' y' | case exists_smul_eq.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
⊢ ∃ g, g • x = y | case exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | suffices g ∈ fixingSubgroup M s by
use ⟨g, this⟩
ext i
simp only [smul_apply, SubMulAction.val_smul_of_tower]
have : (y i : α) = (y.trans (subtype (sᶜ)) i : α) := by
simp only [trans_apply, Function.Embedding.coe_subtype]
rfl
rw [this]
have : (x i : α) = (x.trans (subtype (sᶜ)) i : α) := by
simp only [trans_apply, Function.Embedding.coe_subtype]
rfl
rw [this]
rw [← Function.Embedding.ext_iff] at hx'1 hy'1
simp_rw [← hy'1 i, ← hx'1 i, ← hg]
simp only [trans_apply, smul_apply, RelEmbedding.coe_toEmbedding]
rfl | case exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
⊢ ∃ g, g • x = y | case exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
⊢ g ∈ fixingSubgroup M s | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | intro a | case exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
⊢ g ∈ fixingSubgroup M s | case exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
a : ↑s
⊢ g • ↑a = ↑a | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
⊢ g ∈ fixingSubgroup M s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | have : z.toEmbedding.trans (subtype (s : Set α)) (z.symm a) = a := by
simp only [trans_apply, Equiv.toEmbedding_apply, Equiv.apply_symm_apply,
Function.Embedding.coe_subtype]
rfl | case exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
a : ↑s
⊢ g • ↑a = ↑a | case exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
a : ↑s
this : (Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)) (z.symm a) = ↑a
⊢ g • ↑a = ↑a | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
a : ↑s
⊢ g • ↑a = ↑a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | simp only [← this] | case exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
a : ↑s
this : (Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)) (z.symm a) = ↑a
⊢ g • ↑a = ↑a | case exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
a : ↑s
this : (Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)) (z.symm a) = ↑a
⊢ g • (Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)) (z.symm a) =
(Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)) (z.symm a) | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
a : ↑s
this : (Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)) (z.symm a) = ↑a
⊢ g • ↑a = ↑a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | conv_lhs => rw [← hx'2] | case exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
a : ↑s
this : (Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)) (z.symm a) = ↑a
⊢ g • (Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)) (z.symm a) =
(Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)) (z.symm a) | case exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
a : ↑s
this : (Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)) (z.symm a) = ↑a
⊢ g •
(Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x'))
(z.symm a) =
(Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)) (z.symm a) | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
a : ↑s
this : (Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)) (z.symm a) = ↑a
⊢ g • (Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)) (z.symm a) =
(Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)) (z.symm a)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | rw [← hy'2, ← hg] | case exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
a : ↑s
this : (Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)) (z.symm a) = ↑a
⊢ g •
(Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x'))
(z.symm a) =
(Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)) (z.symm a) | case exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
a : ↑s
this : (Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)) (z.symm a) = ↑a
⊢ g •
(Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x'))
(z.symm a) =
(Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) (g • x')))
(z.symm a) | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
a : ↑s
this : (Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)) (z.symm a) = ↑a
⊢ g •
(Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x'))
(z.symm a) =
(Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)) (z.symm a)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | simp only [trans_apply, smul_apply] | case exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
a : ↑s
this : (Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)) (z.symm a) = ↑a
⊢ g •
(Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x'))
(z.symm a) =
(Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) (g • x')))
(z.symm a) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq.intro.intro.intro.intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
a : ↑s
this : (Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)) (z.symm a) = ↑a
⊢ g •
(Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x'))
(z.symm a) =
(Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) (g • x')))
(z.symm a)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | rw [s.ncard_eq_toFinset_card, PartENat.card_eq_coe_nat_card, Set.Nat.card_coe_set_eq, PartENat.natCast_inj, s.ncard_eq_toFinset_card] | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
⊢ PartENat.card ↑s = ↑(Set.ncard s) | 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 α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
⊢ PartENat.card ↑s = ↑(Set.ncard s)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | use ⟨g, this⟩ | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this : g ∈ fixingSubgroup M s
⊢ ∃ g, g • x = y | case h
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this : g ∈ fixingSubgroup M s
⊢ { val := g, property := this } • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this : g ∈ fixingSubgroup M s
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | ext i | case h
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this : g ∈ fixingSubgroup M s
⊢ { val := g, property := this } • x = y | case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this : g ∈ fixingSubgroup M s
i : Fin m
⊢ ↑(({ val := g, property := this } • x) i) = ↑(y i) | 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 α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this : g ∈ fixingSubgroup M s
⊢ { val := g, property := this } • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | simp only [smul_apply, SubMulAction.val_smul_of_tower] | case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this : g ∈ fixingSubgroup M s
i : Fin m
⊢ ↑(({ val := g, property := this } • x) i) = ↑(y i) | case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this : g ∈ fixingSubgroup M s
i : Fin m
⊢ { val := g, property := this } • ↑(x i) = ↑(y i) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this : g ∈ fixingSubgroup M s
i : Fin m
⊢ ↑(({ val := g, property := this } • x) i) = ↑(y i)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | have : (y i : α) = (y.trans (subtype (sᶜ)) i : α) := by
simp only [trans_apply, Function.Embedding.coe_subtype]
rfl | case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this : g ∈ fixingSubgroup M s
i : Fin m
⊢ { val := g, property := this } • ↑(x i) = ↑(y i) | case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝ : g ∈ fixingSubgroup M s
i : Fin m
this : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
⊢ { val := g, property := this✝ } • ↑(x i) = ↑(y i) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this : g ∈ fixingSubgroup M s
i : Fin m
⊢ { val := g, property := this } • ↑(x i) = ↑(y i)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | rw [this] | case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝ : g ∈ fixingSubgroup M s
i : Fin m
this : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
⊢ { val := g, property := this✝ } • ↑(x i) = ↑(y i) | case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝ : g ∈ fixingSubgroup M s
i : Fin m
this : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
⊢ { val := g, property := this✝ } • ↑(x i) = (Function.Embedding.trans y (subtype sᶜ)) i | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝ : g ∈ fixingSubgroup M s
i : Fin m
this : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
⊢ { val := g, property := this✝ } • ↑(x i) = ↑(y i)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | have : (x i : α) = (x.trans (subtype (sᶜ)) i : α) := by
simp only [trans_apply, Function.Embedding.coe_subtype]
rfl | case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝ : g ∈ fixingSubgroup M s
i : Fin m
this : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
⊢ { val := g, property := this✝ } • ↑(x i) = (Function.Embedding.trans y (subtype sᶜ)) i | case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝¹ : g ∈ fixingSubgroup M s
i : Fin m
this✝ : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
this : ↑(x i) = (Function.Embedding.trans x (subtype sᶜ)) i
⊢ { val := g, property := this✝¹ } • ↑(x i) = (Function.Embedding.trans y (subtype sᶜ)) i | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝ : g ∈ fixingSubgroup M s
i : Fin m
this : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
⊢ { val := g, property := this✝ } • ↑(x i) = (Function.Embedding.trans y (subtype sᶜ)) i
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | rw [this] | case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝¹ : g ∈ fixingSubgroup M s
i : Fin m
this✝ : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
this : ↑(x i) = (Function.Embedding.trans x (subtype sᶜ)) i
⊢ { val := g, property := this✝¹ } • ↑(x i) = (Function.Embedding.trans y (subtype sᶜ)) i | case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝¹ : g ∈ fixingSubgroup M s
i : Fin m
this✝ : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
this : ↑(x i) = (Function.Embedding.trans x (subtype sᶜ)) i
⊢ { val := g, property := this✝¹ } • (Function.Embedding.trans x (subtype sᶜ)) i =
(Function.Embedding.trans y (subtype sᶜ)) i | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝¹ : g ∈ fixingSubgroup M s
i : Fin m
this✝ : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
this : ↑(x i) = (Function.Embedding.trans x (subtype sᶜ)) i
⊢ { val := g, property := this✝¹ } • ↑(x i) = (Function.Embedding.trans y (subtype sᶜ)) i
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | rw [← Function.Embedding.ext_iff] at hx'1 hy'1 | case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝¹ : g ∈ fixingSubgroup M s
i : Fin m
this✝ : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
this : ↑(x i) = (Function.Embedding.trans x (subtype sᶜ)) i
⊢ { val := g, property := this✝¹ } • (Function.Embedding.trans x (subtype sᶜ)) i =
(Function.Embedding.trans y (subtype sᶜ)) i | case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 :
∀ (x_1 : Fin m),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') x_1 = (Function.Embedding.trans x (subtype sᶜ)) x_1
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 :
∀ (x : Fin m),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') x = (Function.Embedding.trans y (subtype sᶜ)) x
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝¹ : g ∈ fixingSubgroup M s
i : Fin m
this✝ : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
this : ↑(x i) = (Function.Embedding.trans x (subtype sᶜ)) i
⊢ { val := g, property := this✝¹ } • (Function.Embedding.trans x (subtype sᶜ)) i =
(Function.Embedding.trans y (subtype sᶜ)) i | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝¹ : g ∈ fixingSubgroup M s
i : Fin m
this✝ : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
this : ↑(x i) = (Function.Embedding.trans x (subtype sᶜ)) i
⊢ { val := g, property := this✝¹ } • (Function.Embedding.trans x (subtype sᶜ)) i =
(Function.Embedding.trans y (subtype sᶜ)) i
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | simp_rw [← hy'1 i, ← hx'1 i, ← hg] | case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 :
∀ (x_1 : Fin m),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') x_1 = (Function.Embedding.trans x (subtype sᶜ)) x_1
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 :
∀ (x : Fin m),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') x = (Function.Embedding.trans y (subtype sᶜ)) x
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝¹ : g ∈ fixingSubgroup M s
i : Fin m
this✝ : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
this : ↑(x i) = (Function.Embedding.trans x (subtype sᶜ)) i
⊢ { val := g, property := this✝¹ } • (Function.Embedding.trans x (subtype sᶜ)) i =
(Function.Embedding.trans y (subtype sᶜ)) i | case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 :
∀ (x_1 : Fin m),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') x_1 = (Function.Embedding.trans x (subtype sᶜ)) x_1
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 :
∀ (x : Fin m),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') x = (Function.Embedding.trans y (subtype sᶜ)) x
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝¹ : g ∈ fixingSubgroup M s
i : Fin m
this✝ : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
this : ↑(x i) = (Function.Embedding.trans x (subtype sᶜ)) i
⊢ { val := g, property := this✝¹ } • (Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') i =
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x')) i | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 :
∀ (x_1 : Fin m),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') x_1 = (Function.Embedding.trans x (subtype sᶜ)) x_1
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 :
∀ (x : Fin m),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') x = (Function.Embedding.trans y (subtype sᶜ)) x
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝¹ : g ∈ fixingSubgroup M s
i : Fin m
this✝ : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
this : ↑(x i) = (Function.Embedding.trans x (subtype sᶜ)) i
⊢ { val := g, property := this✝¹ } • (Function.Embedding.trans x (subtype sᶜ)) i =
(Function.Embedding.trans y (subtype sᶜ)) i
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | simp only [trans_apply, smul_apply, RelEmbedding.coe_toEmbedding] | case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 :
∀ (x_1 : Fin m),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') x_1 = (Function.Embedding.trans x (subtype sᶜ)) x_1
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 :
∀ (x : Fin m),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') x = (Function.Embedding.trans y (subtype sᶜ)) x
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝¹ : g ∈ fixingSubgroup M s
i : Fin m
this✝ : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
this : ↑(x i) = (Function.Embedding.trans x (subtype sᶜ)) i
⊢ { val := g, property := this✝¹ } • (Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') i =
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x')) i | case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 :
∀ (x_1 : Fin m),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') x_1 = (Function.Embedding.trans x (subtype sᶜ)) x_1
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 :
∀ (x : Fin m),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') x = (Function.Embedding.trans y (subtype sᶜ)) x
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝¹ : g ∈ fixingSubgroup M s
i : Fin m
this✝ : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
this : ↑(x i) = (Function.Embedding.trans x (subtype sᶜ)) i
⊢ { val := g, property := this✝¹ } • x' ((Fin.castLEEmb ⋯) i) = g • x' ((Fin.castLEEmb ⋯) i) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 :
∀ (x_1 : Fin m),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') x_1 = (Function.Embedding.trans x (subtype sᶜ)) x_1
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 :
∀ (x : Fin m),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') x = (Function.Embedding.trans y (subtype sᶜ)) x
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝¹ : g ∈ fixingSubgroup M s
i : Fin m
this✝ : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
this : ↑(x i) = (Function.Embedding.trans x (subtype sᶜ)) i
⊢ { val := g, property := this✝¹ } • (Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') i =
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x')) i
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | rfl | case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 :
∀ (x_1 : Fin m),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') x_1 = (Function.Embedding.trans x (subtype sᶜ)) x_1
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 :
∀ (x : Fin m),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') x = (Function.Embedding.trans y (subtype sᶜ)) x
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝¹ : g ∈ fixingSubgroup M s
i : Fin m
this✝ : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
this : ↑(x i) = (Function.Embedding.trans x (subtype sᶜ)) i
⊢ { val := g, property := this✝¹ } • x' ((Fin.castLEEmb ⋯) i) = g • x' ((Fin.castLEEmb ⋯) i) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 :
∀ (x_1 : Fin m),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') x_1 = (Function.Embedding.trans x (subtype sᶜ)) x_1
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 :
∀ (x : Fin m),
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y') x = (Function.Embedding.trans y (subtype sᶜ)) x
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝¹ : g ∈ fixingSubgroup M s
i : Fin m
this✝ : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
this : ↑(x i) = (Function.Embedding.trans x (subtype sᶜ)) i
⊢ { val := g, property := this✝¹ } • x' ((Fin.castLEEmb ⋯) i) = g • x' ((Fin.castLEEmb ⋯) i)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | simp only [trans_apply, Function.Embedding.coe_subtype] | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this : g ∈ fixingSubgroup M s
i : Fin m
⊢ ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this : g ∈ fixingSubgroup M s
i : Fin m
⊢ ↑(y i) = (subtype sᶜ) (y i) | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this : g ∈ fixingSubgroup M s
i : Fin m
⊢ ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | rfl | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this : g ∈ fixingSubgroup M s
i : Fin m
⊢ ↑(y i) = (subtype sᶜ) (y i) | 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 α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this : g ∈ fixingSubgroup M s
i : Fin m
⊢ ↑(y i) = (subtype sᶜ) (y i)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | simp only [trans_apply, Function.Embedding.coe_subtype] | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝ : g ∈ fixingSubgroup M s
i : Fin m
this : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
⊢ ↑(x i) = (Function.Embedding.trans x (subtype sᶜ)) i | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝ : g ∈ fixingSubgroup M s
i : Fin m
this : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
⊢ ↑(x i) = (subtype sᶜ) (x i) | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝ : g ∈ fixingSubgroup M s
i : Fin m
this : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
⊢ ↑(x i) = (Function.Embedding.trans x (subtype sᶜ)) i
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | rfl | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝ : g ∈ fixingSubgroup M s
i : Fin m
this : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
⊢ ↑(x i) = (subtype sᶜ) (x i) | 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 α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
this✝ : g ∈ fixingSubgroup M s
i : Fin m
this : ↑(y i) = (Function.Embedding.trans y (subtype sᶜ)) i
⊢ ↑(x i) = (subtype sᶜ) (x i)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | simp only [trans_apply, Equiv.toEmbedding_apply, Equiv.apply_symm_apply,
Function.Embedding.coe_subtype] | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
a : ↑s
⊢ (Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)) (z.symm a) = ↑a | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
a : ↑s
⊢ (subtype s) 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 α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
a : ↑s
⊢ (Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)) (z.symm a) = ↑a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity | [636, 1] | [681, 38] | rfl | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
a : ↑s
⊢ (subtype s) a = ↑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 α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : n = m + Set.ncard s
hs : PartENat.card ↑s = ↑(Set.ncard s)
x y : Fin m ↪ ↥(SubMulAction.ofFixingSubgroup M s)
z : Fin (Set.ncard s) ≃ ↑s
x' : Fin n ↪ α
hx'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ)
hx'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
y' : Fin n ↪ α
hy'1 : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y' = Function.Embedding.trans y (subtype sᶜ)
hy'2 :
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) y') =
Function.Embedding.trans (Equiv.toEmbedding z) (subtype s)
g : M
hg : g • x' = y'
a : ↑s
⊢ (subtype s) a = ↑a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity' | [684, 1] | [695, 6] | apply remaining_transitivity | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : m + Set.ncard s ≤ n
hn : ↑n ≤ PartENat.card α
⊢ IsMultiplyPretransitive (↥(fixingSubgroup M s)) (↥(SubMulAction.ofFixingSubgroup M s)) m | case h
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : m + Set.ncard s ≤ n
hn : ↑n ≤ PartENat.card α
⊢ IsMultiplyPretransitive M α ?n
case hmn
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : m + Set.ncard s ≤ n
hn : ↑n ≤ PartENat.card α
⊢ ?n = m + Set.ncard s
case n
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : m + Set.ncard s ≤ n
hn : ↑n ≤ PartENat.card α
⊢ ℕ | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : m + Set.ncard s ≤ n
hn : ↑n ≤ PartENat.card α
⊢ IsMultiplyPretransitive (↥(fixingSubgroup M s)) (↥(SubMulAction.ofFixingSubgroup M s)) m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity' | [684, 1] | [695, 6] | exact isMultiplyPretransitive_of_higher M α h hmn hn | case h
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : m + Set.ncard s ≤ n
hn : ↑n ≤ PartENat.card α
⊢ IsMultiplyPretransitive M α ?n
case hmn
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : m + Set.ncard s ≤ n
hn : ↑n ≤ PartENat.card α
⊢ ?n = m + Set.ncard s
case n
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : m + Set.ncard s ≤ n
hn : ↑n ≤ PartENat.card α
⊢ ℕ | case hmn
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : m + Set.ncard s ≤ n
hn : ↑n ≤ PartENat.card α
⊢ m + Set.ncard s = m + Set.ncard s | 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 α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : m + Set.ncard s ≤ n
hn : ↑n ≤ PartENat.card α
⊢ IsMultiplyPretransitive M α ?n
case hmn
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : m + Set.ncard s ≤ n
hn : ↑n ≤ PartENat.card α
⊢ ?n = m + Set.ncard s
case n
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : m + Set.ncard s ≤ n
hn : ↑n ≤ PartENat.card α
⊢ ℕ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.remaining_transitivity' | [684, 1] | [695, 6] | rfl | case hmn
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : m + Set.ncard s ≤ n
hn : ↑n ≤ PartENat.card α
⊢ m + Set.ncard s = m + Set.ncard s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case hmn
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
h : IsMultiplyPretransitive M α n
hmn : m + Set.ncard s ≤ n
hn : ↑n ≤ PartENat.card α
⊢ m + Set.ncard s = m + Set.ncard s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Set.ncard_le_fintype_card | [800, 1] | [803, 41] | rw [← Nat.card_eq_fintype_card, ← Set.ncard_univ] | M : Type ?u.179009
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
s : Set α
⊢ Set.ncard s ≤ Fintype.card α | M : Type ?u.179009
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
s : Set α
⊢ Set.ncard s ≤ Set.ncard Set.univ | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type ?u.179009
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
s : Set α
⊢ Set.ncard s ≤ Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | Set.ncard_le_fintype_card | [800, 1] | [803, 41] | exact Set.ncard_le_ncard s.subset_univ | M : Type ?u.179009
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
s : Set α
⊢ Set.ncard s ≤ Set.ncard Set.univ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type ?u.179009
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
s : Set α
⊢ Set.ncard s ≤ Set.ncard Set.univ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | revert M α | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
k : ℕ
hmk : IsMultiplyPretransitive M α k
s : Set α
hs : Set.ncard s = k
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)! | k : ℕ
⊢ ∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)! | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
k : ℕ
hmk : IsMultiplyPretransitive M α k
s : Set α
hs : Set.ncard s = k
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | induction' k with k hrec | k : ℕ
⊢ ∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)! | case zero
⊢ ∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α zero →
∀ {s : Set α},
Set.ncard s = zero → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
case succ
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
⊢ ∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α (succ k) →
∀ {s : Set α},
Set.ncard s = succ k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)! | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
⊢ ∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | intro M α _ _ _ hmk s hs | case succ
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
⊢ ∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α (succ k) →
∀ {s : Set α},
Set.ncard s = succ k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)! | case succ
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)! | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
⊢ ∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α (succ k) →
∀ {s : Set α},
Set.ncard s = succ k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | have : s.Nonempty := by
rw [← Set.ncard_pos, hs]
exact succ_pos k | case succ
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)! | case succ
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
this : Set.Nonempty s
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)! | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | obtain ⟨a, has⟩ := this | case succ
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
this : Set.Nonempty s
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)! | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)! | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
this : Set.Nonempty s
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | let t : Set (SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)! | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)! | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | have hat : Subtype.val '' t = s \ {a} := by
rw [Set.image_preimage_eq_inter_range]
simp only [Subtype.range_coe_subtype]
rw [Set.diff_eq_compl_inter, Set.inter_comm]
congr | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)! | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)! | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | have hat' : s = insert a (Subtype.val '' t) := by
rw [hat, Set.insert_diff_singleton, Set.insert_eq_of_mem has] | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)! | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)! | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | have hfs : fixingSubgroup M s = ?_ := by
rw [hat']
exact fixingSubgroup_of_insert M a t | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)! | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)! | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | rw [hfs] | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)! | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
⊢ Subgroup.index (Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)) *
(Fintype.card α - Set.ncard s)! =
(Fintype.card α)! | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | rw [Subgroup.index_map] | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
⊢ Subgroup.index (Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)) *
(Fintype.card α - Set.ncard s)! =
(Fintype.card α)! | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t ⊔ MonoidHom.ker (Subgroup.subtype (stabilizer M a))) *
Subgroup.index (MonoidHom.range (Subgroup.subtype (stabilizer M a))) *
(Fintype.card α - Set.ncard s)! =
(Fintype.card α)! | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
⊢ Subgroup.index (Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)) *
(Fintype.card α - Set.ncard s)! =
(Fintype.card α)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | rw [(MonoidHom.ker_eq_bot_iff (stabilizer M a).subtype).mpr
(by simp only [Subgroup.coeSubtype, Subtype.coe_injective])] | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t ⊔ MonoidHom.ker (Subgroup.subtype (stabilizer M a))) *
Subgroup.index (MonoidHom.range (Subgroup.subtype (stabilizer M a))) *
(Fintype.card α - Set.ncard s)! =
(Fintype.card α)! | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t ⊔ ⊥) *
Subgroup.index (MonoidHom.range (Subgroup.subtype (stabilizer M a))) *
(Fintype.card α - Set.ncard s)! =
(Fintype.card α)! | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t ⊔ MonoidHom.ker (Subgroup.subtype (stabilizer M a))) *
Subgroup.index (MonoidHom.range (Subgroup.subtype (stabilizer M a))) *
(Fintype.card α - Set.ncard s)! =
(Fintype.card α)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | simp only [sup_bot_eq, Subgroup.subtype_range] | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t ⊔ ⊥) *
Subgroup.index (MonoidHom.range (Subgroup.subtype (stabilizer M a))) *
(Fintype.card α - Set.ncard s)! =
(Fintype.card α)! | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) * Subgroup.index (stabilizer M a) *
(Fintype.card α - Set.ncard s)! =
(Fintype.card α)! | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t ⊔ ⊥) *
Subgroup.index (MonoidHom.range (Subgroup.subtype (stabilizer M a))) *
(Fintype.card α - Set.ncard s)! =
(Fintype.card α)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | have hscard : s.ncard = 1 + t.ncard := by
rw [hat']
suffices ¬ a ∈ (Subtype.val '' t) by
rw [add_comm]
convert Set.ncard_insert_of_not_mem this ?_
rw [Set.ncard_image_of_injective _ Subtype.coe_injective]
apply Set.toFinite
intro h
obtain ⟨⟨b, hb⟩, _, hb'⟩ := h
apply hb
simp only [Set.mem_singleton_iff]
rw [← hb'] | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) * Subgroup.index (stabilizer M a) *
(Fintype.card α - Set.ncard s)! =
(Fintype.card α)! | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) * Subgroup.index (stabilizer M a) *
(Fintype.card α - Set.ncard s)! =
(Fintype.card α)! | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) * Subgroup.index (stabilizer M a) *
(Fintype.card α - Set.ncard s)! =
(Fintype.card α)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | have htcard : t.ncard = k := by
rw [← Nat.succ_inj', ← hs, hscard, add_comm] | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) * Subgroup.index (stabilizer M a) *
(Fintype.card α - Set.ncard s)! =
(Fintype.card α)! | case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
htcard : Set.ncard t = k
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) * Subgroup.index (stabilizer M a) *
(Fintype.card α - Set.ncard s)! =
(Fintype.card α)! | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) * Subgroup.index (stabilizer M a) *
(Fintype.card α - Set.ncard s)! =
(Fintype.card α)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | intro M α _ _ _ _ s hs | case zero
⊢ ∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α zero →
∀ {s : Set α},
Set.ncard s = zero → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)! | case zero
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk✝ : IsMultiplyPretransitive M α zero
s : Set α
hs : Set.ncard s = zero
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)! | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
⊢ ∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α zero →
∀ {s : Set α},
Set.ncard s = zero → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | simp only [hs, zero_eq, ge_iff_le, nonpos_iff_eq_zero, tsub_zero, ne_eq] | case zero
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk✝ : IsMultiplyPretransitive M α zero
s : Set α
hs : Set.ncard s = zero
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)! | case zero
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk✝ : IsMultiplyPretransitive M α zero
s : Set α
hs : Set.ncard s = zero
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α)! = (Fintype.card α)! | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk✝ : IsMultiplyPretransitive M α zero
s : Set α
hs : Set.ncard s = zero
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | rw [Set.ncard_eq_zero] at hs | case zero
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk✝ : IsMultiplyPretransitive M α zero
s : Set α
hs : Set.ncard s = zero
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α)! = (Fintype.card α)! | case zero
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk✝ : IsMultiplyPretransitive M α zero
s : Set α
hs : s = ∅
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α)! = (Fintype.card α)! | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk✝ : IsMultiplyPretransitive M α zero
s : Set α
hs : Set.ncard s = zero
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α)! = (Fintype.card α)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | simp only [hs] | case zero
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk✝ : IsMultiplyPretransitive M α zero
s : Set α
hs : s = ∅
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α)! = (Fintype.card α)! | case zero
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk✝ : IsMultiplyPretransitive M α zero
s : Set α
hs : s = ∅
⊢ Subgroup.index (fixingSubgroup M ∅) * (Fintype.card α)! = (Fintype.card α)! | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk✝ : IsMultiplyPretransitive M α zero
s : Set α
hs : s = ∅
⊢ Subgroup.index (fixingSubgroup M s) * (Fintype.card α)! = (Fintype.card α)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | suffices fixingSubgroup M ∅ = ⊤ by
rw [this, Subgroup.index_top, one_mul] | case zero
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk✝ : IsMultiplyPretransitive M α zero
s : Set α
hs : s = ∅
⊢ Subgroup.index (fixingSubgroup M ∅) * (Fintype.card α)! = (Fintype.card α)! | case zero
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk✝ : IsMultiplyPretransitive M α zero
s : Set α
hs : s = ∅
⊢ fixingSubgroup M ∅ = ⊤ | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk✝ : IsMultiplyPretransitive M α zero
s : Set α
hs : s = ∅
⊢ Subgroup.index (fixingSubgroup M ∅) * (Fintype.card α)! = (Fintype.card α)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | exact GaloisConnection.l_bot (fixingSubgroup_fixedPoints_gc M α) | case zero
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk✝ : IsMultiplyPretransitive M α zero
s : Set α
hs : s = ∅
⊢ fixingSubgroup M ∅ = ⊤ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk✝ : IsMultiplyPretransitive M α zero
s : Set α
hs : s = ∅
⊢ fixingSubgroup M ∅ = ⊤
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | rw [this, Subgroup.index_top, one_mul] | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk✝ : IsMultiplyPretransitive M α zero
s : Set α
hs : s = ∅
this : fixingSubgroup M ∅ = ⊤
⊢ Subgroup.index (fixingSubgroup M ∅) * (Fintype.card α)! = (Fintype.card α)! | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk✝ : IsMultiplyPretransitive M α zero
s : Set α
hs : s = ∅
this : fixingSubgroup M ∅ = ⊤
⊢ Subgroup.index (fixingSubgroup M ∅) * (Fintype.card α)! = (Fintype.card α)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | rw [isPretransitive_iff_is_one_pretransitive] | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
⊢ IsPretransitive M α | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
⊢ IsMultiplyPretransitive M α 1 | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
⊢ IsPretransitive M α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | apply isMultiplyPretransitive_of_higher M α hmk | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
⊢ IsMultiplyPretransitive M α 1 | case hmn
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
⊢ 1 ≤ succ k
case hα
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
⊢ ↑(succ k) ≤ PartENat.card α | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
⊢ IsMultiplyPretransitive M α 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | rw [Nat.succ_le_succ_iff] | case hmn
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
⊢ 1 ≤ succ k | case hmn
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
⊢ 0 ≤ k | Please generate a tactic in lean4 to solve the state.
STATE:
case hmn
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
⊢ 1 ≤ succ k
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | apply Nat.zero_le | case hmn
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
⊢ 0 ≤ k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case hmn
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
⊢ 0 ≤ k
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | rw [← hs] | case hα
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
⊢ ↑(succ k) ≤ PartENat.card α | case hα
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
⊢ ↑(Set.ncard s) ≤ PartENat.card α | Please generate a tactic in lean4 to solve the state.
STATE:
case hα
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
⊢ ↑(succ k) ≤ PartENat.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | simp only [PartENat.card_eq_coe_fintype_card, Fintype.card_coe, PartENat.coe_le_coe] | case hα
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
⊢ ↑(Set.ncard s) ≤ PartENat.card α | case hα
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
⊢ Set.ncard s ≤ Fintype.card α | Please generate a tactic in lean4 to solve the state.
STATE:
case hα
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
⊢ ↑(Set.ncard s) ≤ PartENat.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | apply Set.ncard_le_fintype_card | case hα
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
⊢ Set.ncard s ≤ Fintype.card α | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case hα
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
⊢ Set.ncard s ≤ Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | rw [← Set.ncard_pos, hs] | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
⊢ Set.Nonempty s | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
⊢ 0 < succ k | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
⊢ Set.Nonempty s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | exact succ_pos k | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
⊢ 0 < succ k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
⊢ 0 < succ k
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | rw [Set.image_preimage_eq_inter_range] | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
⊢ Subtype.val '' t = s \ {a} | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
⊢ s ∩ Set.range Subtype.val = s \ {a} | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
⊢ Subtype.val '' t = s \ {a}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | simp only [Subtype.range_coe_subtype] | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
⊢ s ∩ Set.range Subtype.val = s \ {a} | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
⊢ s ∩ {x | x ∈ SubMulAction.ofStabilizer M a} = s \ {a} | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
⊢ s ∩ Set.range Subtype.val = s \ {a}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | rw [Set.diff_eq_compl_inter, Set.inter_comm] | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
⊢ s ∩ {x | x ∈ SubMulAction.ofStabilizer M a} = s \ {a} | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
⊢ {x | x ∈ SubMulAction.ofStabilizer M a} ∩ s = {a}ᶜ ∩ s | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
⊢ s ∩ {x | x ∈ SubMulAction.ofStabilizer M a} = s \ {a}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | congr | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
⊢ {x | x ∈ SubMulAction.ofStabilizer M a} ∩ s = {a}ᶜ ∩ s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
⊢ {x | x ∈ SubMulAction.ofStabilizer M a} ∩ s = {a}ᶜ ∩ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | rw [hat, Set.insert_diff_singleton, Set.insert_eq_of_mem has] | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
⊢ s = insert a (Subtype.val '' t) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
⊢ s = insert a (Subtype.val '' t)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | rw [hat'] | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
⊢ fixingSubgroup M s = ?m.186999 | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
⊢ fixingSubgroup M (insert a (Subtype.val '' t)) = ?m.186999
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
⊢ Subgroup M | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
⊢ fixingSubgroup M s = ?m.186999
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | exact fixingSubgroup_of_insert M a t | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
⊢ fixingSubgroup M (insert a (Subtype.val '' t)) = ?m.186999
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
⊢ Subgroup M | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
⊢ fixingSubgroup M (insert a (Subtype.val '' t)) = ?m.186999
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
⊢ Subgroup M
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | simp only [Subgroup.coeSubtype, Subtype.coe_injective] | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
⊢ Function.Injective ⇑(Subgroup.subtype (stabilizer M a)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
⊢ Function.Injective ⇑(Subgroup.subtype (stabilizer M a))
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | rw [hat'] | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
⊢ Set.ncard s = 1 + Set.ncard t | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
⊢ Set.ncard (insert a (Subtype.val '' t)) = 1 + Set.ncard t | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
⊢ Set.ncard s = 1 + Set.ncard t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | suffices ¬ a ∈ (Subtype.val '' t) by
rw [add_comm]
convert Set.ncard_insert_of_not_mem this ?_
rw [Set.ncard_image_of_injective _ Subtype.coe_injective]
apply Set.toFinite | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
⊢ Set.ncard (insert a (Subtype.val '' t)) = 1 + Set.ncard t | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
⊢ a ∉ Subtype.val '' t | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
⊢ Set.ncard (insert a (Subtype.val '' t)) = 1 + Set.ncard t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | intro h | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
⊢ a ∉ Subtype.val '' t | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
h : a ∈ Subtype.val '' t
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
⊢ a ∉ Subtype.val '' t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | obtain ⟨⟨b, hb⟩, _, hb'⟩ := h | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
h : a ∈ Subtype.val '' t
⊢ False | case intro.mk.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
b : α
hb : b ∈ SubMulAction.ofStabilizer M a
left✝ : { val := b, property := hb } ∈ t
hb' : ↑{ val := b, property := hb } = a
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
h : a ∈ Subtype.val '' t
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | apply hb | case intro.mk.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
b : α
hb : b ∈ SubMulAction.ofStabilizer M a
left✝ : { val := b, property := hb } ∈ t
hb' : ↑{ val := b, property := hb } = a
⊢ False | case intro.mk.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
b : α
hb : b ∈ SubMulAction.ofStabilizer M a
left✝ : { val := b, property := hb } ∈ t
hb' : ↑{ val := b, property := hb } = a
⊢ b ∈ {a} | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.mk.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
b : α
hb : b ∈ SubMulAction.ofStabilizer M a
left✝ : { val := b, property := hb } ∈ t
hb' : ↑{ val := b, property := hb } = a
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | simp only [Set.mem_singleton_iff] | case intro.mk.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
b : α
hb : b ∈ SubMulAction.ofStabilizer M a
left✝ : { val := b, property := hb } ∈ t
hb' : ↑{ val := b, property := hb } = a
⊢ b ∈ {a} | case intro.mk.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
b : α
hb : b ∈ SubMulAction.ofStabilizer M a
left✝ : { val := b, property := hb } ∈ t
hb' : ↑{ val := b, property := hb } = a
⊢ b = a | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.mk.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
b : α
hb : b ∈ SubMulAction.ofStabilizer M a
left✝ : { val := b, property := hb } ∈ t
hb' : ↑{ val := b, property := hb } = a
⊢ b ∈ {a}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | rw [← hb'] | case intro.mk.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
b : α
hb : b ∈ SubMulAction.ofStabilizer M a
left✝ : { val := b, property := hb } ∈ t
hb' : ↑{ val := b, property := hb } = a
⊢ b = a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.mk.intro
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
b : α
hb : b ∈ SubMulAction.ofStabilizer M a
left✝ : { val := b, property := hb } ∈ t
hb' : ↑{ val := b, property := hb } = a
⊢ b = a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | rw [add_comm] | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
this : a ∉ Subtype.val '' t
⊢ Set.ncard (insert a (Subtype.val '' t)) = 1 + Set.ncard t | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
this : a ∉ Subtype.val '' t
⊢ Set.ncard (insert a (Subtype.val '' t)) = Set.ncard t + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
this : a ∉ Subtype.val '' t
⊢ Set.ncard (insert a (Subtype.val '' t)) = 1 + Set.ncard t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | convert Set.ncard_insert_of_not_mem this ?_ | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
this : a ∉ Subtype.val '' t
⊢ Set.ncard (insert a (Subtype.val '' t)) = Set.ncard t + 1 | case h.e'_3.h.e'_5
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
this : a ∉ Subtype.val '' t
⊢ Set.ncard t = Set.ncard (Subtype.val '' t)
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
this : a ∉ Subtype.val '' t
⊢ Set.Finite (Subtype.val '' t) | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
this : a ∉ Subtype.val '' t
⊢ Set.ncard (insert a (Subtype.val '' t)) = Set.ncard t + 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | rw [Set.ncard_image_of_injective _ Subtype.coe_injective] | case h.e'_3.h.e'_5
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
this : a ∉ Subtype.val '' t
⊢ Set.ncard t = Set.ncard (Subtype.val '' t)
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
this : a ∉ Subtype.val '' t
⊢ Set.Finite (Subtype.val '' t) | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
this : a ∉ Subtype.val '' t
⊢ Set.Finite (Subtype.val '' t) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_5
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
this : a ∉ Subtype.val '' t
⊢ Set.ncard t = Set.ncard (Subtype.val '' t)
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
this : a ∉ Subtype.val '' t
⊢ Set.Finite (Subtype.val '' t)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | apply Set.toFinite | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
this : a ∉ Subtype.val '' t
⊢ Set.Finite (Subtype.val '' t) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
this : a ∉ Subtype.val '' t
⊢ Set.Finite (Subtype.val '' t)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | rw [← Nat.succ_inj', ← hs, hscard, add_comm] | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
⊢ Set.ncard t = k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
⊢ Set.ncard t = k
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | rw [mul_comm] at this | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
htcard : Set.ncard t = k
this :
Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) * (Fintype.card α - 1 - Set.ncard t)! = (Fintype.card α - 1)!
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) * Subgroup.index (stabilizer M a) *
(Fintype.card α - Set.ncard s)! =
(Fintype.card α)! | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
htcard : Set.ncard t = k
this :
(Fintype.card α - 1 - Set.ncard t)! * Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) = (Fintype.card α - 1)!
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) * Subgroup.index (stabilizer M a) *
(Fintype.card α - Set.ncard s)! =
(Fintype.card α)! | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
htcard : Set.ncard t = k
this :
Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) * (Fintype.card α - 1 - Set.ncard t)! = (Fintype.card α - 1)!
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) * Subgroup.index (stabilizer M a) *
(Fintype.card α - Set.ncard s)! =
(Fintype.card α)!
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.IsMultiplyPretransitive.index_of_fixing_subgroup_aux | [807, 9] | [887, 30] | rw [hscard, mul_comm, ← mul_assoc, mul_comm, Nat.sub_add_eq, this] | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
htcard : Set.ncard t = k
this :
(Fintype.card α - 1 - Set.ncard t)! * Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) = (Fintype.card α - 1)!
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) * Subgroup.index (stabilizer M a) *
(Fintype.card α - Set.ncard s)! =
(Fintype.card α)! | k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
htcard : Set.ncard t = k
this :
(Fintype.card α - 1 - Set.ncard t)! * Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) = (Fintype.card α - 1)!
⊢ Subgroup.index (stabilizer M a) * (Fintype.card α - 1)! = (Fintype.card α)! | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
hrec :
∀ (M : Type u_2) (α : Type u_1) [inst : Group M] [inst_1 : MulAction M α] [inst_2 : Fintype α],
IsMultiplyPretransitive M α k →
∀ {s : Set α},
Set.ncard s = k → Subgroup.index (fixingSubgroup M s) * (Fintype.card α - Set.ncard s)! = (Fintype.card α)!
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
inst✝ : Fintype α
hmk : IsMultiplyPretransitive M α (succ k)
s : Set α
hs : Set.ncard s = succ k
hGX : IsPretransitive M α
a : α
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hat : Subtype.val '' t = s \ {a}
hat' : s = insert a (Subtype.val '' t)
hfs : fixingSubgroup M s = Subgroup.map (Subgroup.subtype (stabilizer M a)) (fixingSubgroup (↥(stabilizer M a)) t)
hscard : Set.ncard s = 1 + Set.ncard t
htcard : Set.ncard t = k
this :
(Fintype.card α - 1 - Set.ncard t)! * Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) = (Fintype.card α - 1)!
⊢ Subgroup.index (fixingSubgroup (↥(stabilizer M a)) t) * Subgroup.index (stabilizer M a) *
(Fintype.card α - Set.ncard s)! =
(Fintype.card α)!
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.