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/MultiplePrimitivity.lean | MulAction.stabilizer.isMultiplyPreprimitive | [97, 1] | [173, 67] | rw [hxa] | case pos
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : x = a
⊢ x ∈ insert a (Subtype.val '' t)
case neg
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ x ∈ insert a (Subtype.val '' t) | case pos
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : x = a
⊢ a ∈ insert a (Subtype.val '' t)
case neg
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ x ∈ insert a (Subtype.val '' t) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : x = a
⊢ x ∈ insert a (Subtype.val '' t)
case neg
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ x ∈ insert a (Subtype.val '' t)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.stabilizer.isMultiplyPreprimitive | [97, 1] | [173, 67] | apply Set.mem_insert | case pos
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : x = a
⊢ a ∈ insert a (Subtype.val '' t)
case neg
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ x ∈ insert a (Subtype.val '' t) | case neg
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ x ∈ insert a (Subtype.val '' t) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : x = a
⊢ a ∈ insert a (Subtype.val '' t)
case neg
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ x ∈ insert a (Subtype.val '' t)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.stabilizer.isMultiplyPreprimitive | [97, 1] | [173, 67] | apply Set.mem_insert_of_mem | case neg
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ x ∈ insert a (Subtype.val '' t) | case neg.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ x ∈ Subtype.val '' t | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ x ∈ insert a (Subtype.val '' t)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.stabilizer.isMultiplyPreprimitive | [97, 1] | [173, 67] | use ⟨x, ?_⟩ | case neg.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ x ∈ Subtype.val '' t | case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ { val := x, property := ?w } ∈ t ∧ ↑{ val := x, property := ?w } = x
case w
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ x ∈ SubMulAction.ofStabilizer M a | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ x ∈ Subtype.val '' t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.stabilizer.isMultiplyPreprimitive | [97, 1] | [173, 67] | refine' And.intro _ rfl | case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ { val := x, property := ?w } ∈ t ∧ ↑{ val := x, property := ?w } = x
case w
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ x ∈ SubMulAction.ofStabilizer M a | case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ { val := x, property := ?w } ∈ t
case w
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ x ∈ SubMulAction.ofStabilizer M a | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ { val := x, property := ?w } ∈ t ∧ ↑{ val := x, property := ?w } = x
case w
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ x ∈ SubMulAction.ofStabilizer M a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.stabilizer.isMultiplyPreprimitive | [97, 1] | [173, 67] | exact hxa | case w
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ x ∈ SubMulAction.ofStabilizer M a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case w
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ x ∈ SubMulAction.ofStabilizer M a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.stabilizer.isMultiplyPreprimitive | [97, 1] | [173, 67] | simp only [t, Set.mem_preimage] | case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ { val := x, property := ?w } ∈ t | case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ x ∈ 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 α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ { val := x, property := ?w } ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.stabilizer.isMultiplyPreprimitive | [97, 1] | [173, 67] | exact hxs | case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ x ∈ s | no goals | 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 α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxs : x ∈ s
hxa : ¬x = a
⊢ x ∈ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.stabilizer.isMultiplyPreprimitive | [97, 1] | [173, 67] | intro hxat | case h.mpr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
⊢ x ∈ insert a (Subtype.val '' t) → x ∈ s | case h.mpr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxat : x ∈ insert a (Subtype.val '' t)
⊢ x ∈ s | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
⊢ x ∈ insert a (Subtype.val '' t) → x ∈ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.stabilizer.isMultiplyPreprimitive | [97, 1] | [173, 67] | cases' Set.mem_insert_iff.mp hxat with hxa hxt | case h.mpr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxat : x ∈ insert a (Subtype.val '' t)
⊢ x ∈ s | case h.mpr.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxat : x ∈ insert a (Subtype.val '' t)
hxa : x = a
⊢ x ∈ s
case h.mpr.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxat : x ∈ insert a (Subtype.val '' t)
hxt : x ∈ Subtype.val '' t
⊢ x ∈ s | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxat : x ∈ insert a (Subtype.val '' t)
⊢ x ∈ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.stabilizer.isMultiplyPreprimitive | [97, 1] | [173, 67] | rw [hxa] | case h.mpr.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxat : x ∈ insert a (Subtype.val '' t)
hxa : x = a
⊢ x ∈ s
case h.mpr.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxat : x ∈ insert a (Subtype.val '' t)
hxt : x ∈ Subtype.val '' t
⊢ x ∈ s | case h.mpr.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxat : x ∈ insert a (Subtype.val '' t)
hxa : x = a
⊢ a ∈ s
case h.mpr.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxat : x ∈ insert a (Subtype.val '' t)
hxt : x ∈ Subtype.val '' t
⊢ x ∈ s | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxat : x ∈ insert a (Subtype.val '' t)
hxa : x = a
⊢ x ∈ s
case h.mpr.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxat : x ∈ insert a (Subtype.val '' t)
hxt : x ∈ Subtype.val '' t
⊢ x ∈ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.stabilizer.isMultiplyPreprimitive | [97, 1] | [173, 67] | exact has | case h.mpr.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxat : x ∈ insert a (Subtype.val '' t)
hxa : x = a
⊢ a ∈ s
case h.mpr.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxat : x ∈ insert a (Subtype.val '' t)
hxt : x ∈ Subtype.val '' t
⊢ x ∈ s | case h.mpr.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxat : x ∈ insert a (Subtype.val '' t)
hxt : x ∈ Subtype.val '' t
⊢ x ∈ s | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxat : x ∈ insert a (Subtype.val '' t)
hxa : x = a
⊢ a ∈ s
case h.mpr.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxat : x ∈ insert a (Subtype.val '' t)
hxt : x ∈ Subtype.val '' t
⊢ x ∈ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.stabilizer.isMultiplyPreprimitive | [97, 1] | [173, 67] | obtain ⟨y, hy, rfl⟩ := hxt | case h.mpr.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxat : x ∈ insert a (Subtype.val '' t)
hxt : x ∈ Subtype.val '' t
⊢ x ∈ s | case h.mpr.inr.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
y : ↥(SubMulAction.ofStabilizer M a)
hy : y ∈ t
hxat : ↑y ∈ insert a (Subtype.val '' t)
⊢ ↑y ∈ s | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
x : α
hxat : x ∈ insert a (Subtype.val '' t)
hxt : x ∈ Subtype.val '' t
⊢ x ∈ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.stabilizer.isMultiplyPreprimitive | [97, 1] | [173, 67] | simpa only using hy | case h.mpr.inr.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
y : ↥(SubMulAction.ofStabilizer M a)
hy : y ∈ t
hxat : ↑y ∈ insert a (Subtype.val '' t)
⊢ ↑y ∈ s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr.inr.intro.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
y : ↥(SubMulAction.ofStabilizer M a)
hy : y ∈ t
hxat : ↑y ∈ insert a (Subtype.val '' t)
⊢ ↑y ∈ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.stabilizer.isMultiplyPreprimitive | [97, 1] | [173, 67] | apply hn_0.right t | case mpr.right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hst : s = insert a (Subtype.val '' t)
⊢ IsPreprimitive ↥(fixingSubgroup (↥(stabilizer M a)) t) ↥(SubMulAction.ofFixingSubgroup (↥(stabilizer M a)) t) | case mpr.right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hst : s = insert a (Subtype.val '' t)
⊢ Set.encard t + 1 = ↑n | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hst : s = insert a (Subtype.val '' t)
⊢ IsPreprimitive ↥(fixingSubgroup (↥(stabilizer M a)) t) ↥(SubMulAction.ofFixingSubgroup (↥(stabilizer M a)) t)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.stabilizer.isMultiplyPreprimitive | [97, 1] | [173, 67] | rw [← hs, hst, Set.encard_insert_of_not_mem, Subtype.coe_injective.encard_image] | case mpr.right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hst : s = insert a (Subtype.val '' t)
⊢ Set.encard t + 1 = ↑n | case mpr.right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hst : s = insert a (Subtype.val '' t)
⊢ a ∉ Subtype.val '' t | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hst : s = insert a (Subtype.val '' t)
⊢ Set.encard t + 1 = ↑n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.stabilizer.isMultiplyPreprimitive | [97, 1] | [173, 67] | rintro ⟨x, hx⟩ | case mpr.right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hst : s = insert a (Subtype.val '' t)
⊢ a ∉ Subtype.val '' t | case mpr.right.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hst : s = insert a (Subtype.val '' t)
x : ↥(SubMulAction.ofStabilizer M a)
hx : x ∈ t ∧ ↑x = a
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hst : s = insert a (Subtype.val '' t)
⊢ a ∉ Subtype.val '' t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.stabilizer.isMultiplyPreprimitive | [97, 1] | [173, 67] | apply x.prop | case mpr.right.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hst : s = insert a (Subtype.val '' t)
x : ↥(SubMulAction.ofStabilizer M a)
hx : x ∈ t ∧ ↑x = a
⊢ False | case mpr.right.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hst : s = insert a (Subtype.val '' t)
x : ↥(SubMulAction.ofStabilizer M a)
hx : x ∈ t ∧ ↑x = a
⊢ ↑x ∈ {a} | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.right.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hst : s = insert a (Subtype.val '' t)
x : ↥(SubMulAction.ofStabilizer M a)
hx : x ∈ t ∧ ↑x = a
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.stabilizer.isMultiplyPreprimitive | [97, 1] | [173, 67] | rw [hx.right] | case mpr.right.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hst : s = insert a (Subtype.val '' t)
x : ↥(SubMulAction.ofStabilizer M a)
hx : x ∈ t ∧ ↑x = a
⊢ ↑x ∈ {a} | case mpr.right.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hst : s = insert a (Subtype.val '' t)
x : ↥(SubMulAction.ofStabilizer M a)
hx : x ∈ t ∧ ↑x = a
⊢ a ∈ {a} | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.right.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hst : s = insert a (Subtype.val '' t)
x : ↥(SubMulAction.ofStabilizer M a)
hx : x ∈ t ∧ ↑x = a
⊢ ↑x ∈ {a}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.stabilizer.isMultiplyPreprimitive | [97, 1] | [173, 67] | simp only [Set.mem_singleton] | case mpr.right.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hst : s = insert a (Subtype.val '' t)
x : ↥(SubMulAction.ofStabilizer M a)
hx : x ∈ t ∧ ↑x = a
⊢ a ∈ {a} | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.right.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : 1 ≤ n
h : IsPretransitive M α
a : α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
hn_0 : IsMultiplyPreprimitive (↥(stabilizer M a)) (↥(SubMulAction.ofStabilizer M a)) n
s : Set α
hs : Set.encard s = ↑n
has : a ∈ s
t : Set ↥(SubMulAction.ofStabilizer M a) := Subtype.val ⁻¹' s
hst : s = insert a (Subtype.val '' t)
x : ↥(SubMulAction.ofStabilizer M a)
hx : x ∈ t ∧ ↑x = a
⊢ a ∈ {a}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.remaining_primitivity | [227, 1] | [252, 23] | constructor | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
⊢ IsMultiplyPreprimitive (↥(fixingSubgroup M s)) (↥(SubMulAction.ofFixingSubgroup M s)) m | case left
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
⊢ IsMultiplyPretransitive (↥(fixingSubgroup M s)) (↥(SubMulAction.ofFixingSubgroup M s)) m
case right
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
⊢ ∀ (s_1 : Set ↥(SubMulAction.ofFixingSubgroup M s)),
Set.encard s_1 + 1 = ↑m →
IsPreprimitive ↥(fixingSubgroup (↥(fixingSubgroup M s)) s_1)
↥(SubMulAction.ofFixingSubgroup (↥(fixingSubgroup M s)) s_1) | 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
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
⊢ IsMultiplyPreprimitive (↥(fixingSubgroup M s)) (↥(SubMulAction.ofFixingSubgroup M s)) m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.remaining_primitivity | [227, 1] | [252, 23] | apply remaining_transitivity M α s h.left hs | case left
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
⊢ IsMultiplyPretransitive (↥(fixingSubgroup M s)) (↥(SubMulAction.ofFixingSubgroup M s)) m | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case left
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
⊢ IsMultiplyPretransitive (↥(fixingSubgroup M s)) (↥(SubMulAction.ofFixingSubgroup M s)) m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.remaining_primitivity | [227, 1] | [252, 23] | intro t ht | case right
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
⊢ ∀ (s_1 : Set ↥(SubMulAction.ofFixingSubgroup M s)),
Set.encard s_1 + 1 = ↑m →
IsPreprimitive ↥(fixingSubgroup (↥(fixingSubgroup M s)) s_1)
↥(SubMulAction.ofFixingSubgroup (↥(fixingSubgroup M s)) s_1) | case right
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
⊢ IsPreprimitive ↥(fixingSubgroup (↥(fixingSubgroup M s)) t) ↥(SubMulAction.ofFixingSubgroup (↥(fixingSubgroup M s)) t) | Please generate a tactic in lean4 to solve the state.
STATE:
case right
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
⊢ ∀ (s_1 : Set ↥(SubMulAction.ofFixingSubgroup M s)),
Set.encard s_1 + 1 = ↑m →
IsPreprimitive ↥(fixingSubgroup (↥(fixingSubgroup M s)) s_1)
↥(SubMulAction.ofFixingSubgroup (↥(fixingSubgroup M s)) s_1)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.remaining_primitivity | [227, 1] | [252, 23] | let t' : Set α := Subtype.val '' t | case right
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
⊢ IsPreprimitive ↥(fixingSubgroup (↥(fixingSubgroup M s)) t) ↥(SubMulAction.ofFixingSubgroup (↥(fixingSubgroup M s)) t) | case right
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
⊢ IsPreprimitive ↥(fixingSubgroup (↥(fixingSubgroup M s)) t) ↥(SubMulAction.ofFixingSubgroup (↥(fixingSubgroup M s)) t) | Please generate a tactic in lean4 to solve the state.
STATE:
case right
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
⊢ IsPreprimitive ↥(fixingSubgroup (↥(fixingSubgroup M s)) t) ↥(SubMulAction.ofFixingSubgroup (↥(fixingSubgroup M s)) t)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.remaining_primitivity | [227, 1] | [252, 23] | have htt' : t = Subtype.val ⁻¹' t' := by
apply symm
apply Set.preimage_image_eq
exact Subtype.coe_injective | case right
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
⊢ IsPreprimitive ↥(fixingSubgroup (↥(fixingSubgroup M s)) t) ↥(SubMulAction.ofFixingSubgroup (↥(fixingSubgroup M s)) t) | case right
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ IsPreprimitive ↥(fixingSubgroup (↥(fixingSubgroup M s)) t) ↥(SubMulAction.ofFixingSubgroup (↥(fixingSubgroup M s)) t) | Please generate a tactic in lean4 to solve the state.
STATE:
case right
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
⊢ IsPreprimitive ↥(fixingSubgroup (↥(fixingSubgroup M s)) t) ↥(SubMulAction.ofFixingSubgroup (↥(fixingSubgroup M s)) t)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.remaining_primitivity | [227, 1] | [252, 23] | rw [htt'] | case right
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ IsPreprimitive ↥(fixingSubgroup (↥(fixingSubgroup M s)) t) ↥(SubMulAction.ofFixingSubgroup (↥(fixingSubgroup M s)) t) | case right
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ IsPreprimitive ↥(fixingSubgroup (↥(fixingSubgroup M s)) (Subtype.val ⁻¹' t'))
↥(SubMulAction.ofFixingSubgroup (↥(fixingSubgroup M s)) (Subtype.val ⁻¹' t')) | Please generate a tactic in lean4 to solve the state.
STATE:
case right
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ IsPreprimitive ↥(fixingSubgroup (↥(fixingSubgroup M s)) t) ↥(SubMulAction.ofFixingSubgroup (↥(fixingSubgroup M s)) t)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.remaining_primitivity | [227, 1] | [252, 23] | apply isPreprimitive_of_surjective_map
(SubMulAction.OfFixingSubgroupUnion.map_bijective M s t').surjective | case right
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ IsPreprimitive ↥(fixingSubgroup (↥(fixingSubgroup M s)) (Subtype.val ⁻¹' t'))
↥(SubMulAction.ofFixingSubgroup (↥(fixingSubgroup M s)) (Subtype.val ⁻¹' t')) | case right
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ IsPreprimitive ↥(fixingSubgroup M (s ∪ t')) ↥(SubMulAction.ofFixingSubgroup M (s ∪ t')) | Please generate a tactic in lean4 to solve the state.
STATE:
case right
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ IsPreprimitive ↥(fixingSubgroup (↥(fixingSubgroup M s)) (Subtype.val ⁻¹' t'))
↥(SubMulAction.ofFixingSubgroup (↥(fixingSubgroup M s)) (Subtype.val ⁻¹' t'))
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.remaining_primitivity | [227, 1] | [252, 23] | apply h.right | case right
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ IsPreprimitive ↥(fixingSubgroup M (s ∪ t')) ↥(SubMulAction.ofFixingSubgroup M (s ∪ t')) | case right.x
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ Set.encard (s ∪ t') + 1 = ↑n | Please generate a tactic in lean4 to solve the state.
STATE:
case right
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ IsPreprimitive ↥(fixingSubgroup M (s ∪ t')) ↥(SubMulAction.ofFixingSubgroup M (s ∪ t'))
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.remaining_primitivity | [227, 1] | [252, 23] | rw [Set.encard_union_eq _] | case right.x
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ Set.encard (s ∪ t') + 1 = ↑n | case right.x
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ Set.encard s + Set.encard t' + 1 = ↑n
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ Disjoint s t' | Please generate a tactic in lean4 to solve the state.
STATE:
case right.x
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ Set.encard (s ∪ t') + 1 = ↑n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.remaining_primitivity | [227, 1] | [252, 23] | apply symm | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
⊢ t = Subtype.val ⁻¹' t' | case a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
⊢ Subtype.val ⁻¹' t' = t | 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
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
⊢ t = Subtype.val ⁻¹' t'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.remaining_primitivity | [227, 1] | [252, 23] | apply Set.preimage_image_eq | case a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
⊢ Subtype.val ⁻¹' t' = t | case a.h
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
⊢ Function.Injective Subtype.val | Please generate a tactic in lean4 to solve the state.
STATE:
case a
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
⊢ Subtype.val ⁻¹' t' = t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.remaining_primitivity | [227, 1] | [252, 23] | exact Subtype.coe_injective | case a.h
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
⊢ Function.Injective Subtype.val | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.h
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
⊢ Function.Injective Subtype.val
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.remaining_primitivity | [227, 1] | [252, 23] | rw [Subtype.coe_injective.encard_image, add_assoc, ht, hs, add_comm, Nat.cast_add] | case right.x
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ Set.encard s + Set.encard t' + 1 = ↑n | case right.x
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ ↑m + Set.encard s = ↑m + ↑(Set.ncard s) | Please generate a tactic in lean4 to solve the state.
STATE:
case right.x
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ Set.encard s + Set.encard t' + 1 = ↑n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.remaining_primitivity | [227, 1] | [252, 23] | rw [Set.Finite.cast_ncard_eq] | case right.x
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ ↑m + Set.encard s = ↑m + ↑(Set.ncard s) | case right.x
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ Set.Finite s | Please generate a tactic in lean4 to solve the state.
STATE:
case right.x
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ ↑m + Set.encard s = ↑m + ↑(Set.ncard s)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.remaining_primitivity | [227, 1] | [252, 23] | exact Set.toFinite s | case right.x
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ Set.Finite s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case right.x
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ Set.Finite s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.remaining_primitivity | [227, 1] | [252, 23] | rw [Set.disjoint_iff] | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ Disjoint s t' | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ s ∩ t' ⊆ ∅ | 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
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ Disjoint s t'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.remaining_primitivity | [227, 1] | [252, 23] | intro a | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ s ∩ t' ⊆ ∅ | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
a : α
⊢ a ∈ s ∩ t' → 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
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
⊢ s ∩ t' ⊆ ∅
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.remaining_primitivity | [227, 1] | [252, 23] | rintro ⟨hbs, ⟨b, _, rfl⟩⟩ | M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
a : α
⊢ a ∈ s ∩ t' → a ∈ ∅ | case intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
b : ↥(SubMulAction.ofFixingSubgroup M s)
left✝ : b ∈ t
hbs : ↑b ∈ s
⊢ ↑b ∈ ∅ | 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
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
a : α
⊢ a ∈ s ∩ t' → a ∈ ∅
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.remaining_primitivity | [227, 1] | [252, 23] | exfalso | case intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
b : ↥(SubMulAction.ofFixingSubgroup M s)
left✝ : b ∈ t
hbs : ↑b ∈ s
⊢ ↑b ∈ ∅ | case intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
b : ↥(SubMulAction.ofFixingSubgroup M s)
left✝ : b ∈ t
hbs : ↑b ∈ s
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
b : ↥(SubMulAction.ofFixingSubgroup M s)
left✝ : b ∈ t
hbs : ↑b ∈ s
⊢ ↑b ∈ ∅
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.remaining_primitivity | [227, 1] | [252, 23] | exact b.prop hbs | case intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
b : ↥(SubMulAction.ofFixingSubgroup M s)
left✝ : b ∈ t
hbs : ↑b ∈ s
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro
M : Type u_2
α : Type u_1
inst✝² : Group M
inst✝¹ : MulAction M α
m n : ℕ
s : Set α
inst✝ : Finite ↑s
hs : n = m + Set.ncard s
h : IsMultiplyPreprimitive M α n
t : Set ↥(SubMulAction.ofFixingSubgroup M s)
ht : Set.encard t + 1 = ↑m
t' : Set α := Subtype.val '' t
htt' : t = Subtype.val ⁻¹' t'
b : ↥(SubMulAction.ofFixingSubgroup M s)
left✝ : b ∈ t
hbs : ↑b ∈ s
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_multiply_pretransitive_succ | [256, 1] | [276, 46] | cases' Nat.eq_zero_or_pos n with hn hn | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
⊢ IsMultiplyPreprimitive M α n | case inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n = 0
⊢ IsMultiplyPreprimitive M α n
case inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ IsMultiplyPreprimitive M α n | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
⊢ IsMultiplyPreprimitive M α n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_multiply_pretransitive_succ | [256, 1] | [276, 46] | constructor | case inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ IsMultiplyPreprimitive M α n | case inr.left
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ IsMultiplyPretransitive M α n
case inr.right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ ∀ (s : Set α), Set.encard s + 1 = ↑n → IsPreprimitive ↥(fixingSubgroup M s) ↥(SubMulAction.ofFixingSubgroup M s) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ IsMultiplyPreprimitive M α n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_multiply_pretransitive_succ | [256, 1] | [276, 46] | apply isMultiplyPretransitive_of_higher M α h | case inr.left
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ IsMultiplyPretransitive M α n
case inr.right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ ∀ (s : Set α), Set.encard s + 1 = ↑n → IsPreprimitive ↥(fixingSubgroup M s) ↥(SubMulAction.ofFixingSubgroup M s) | case inr.left.hmn
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ n ≤ Nat.succ n
case inr.left.hα
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ ↑(Nat.succ n) ≤ PartENat.card α
case inr.right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ ∀ (s : Set α), Set.encard s + 1 = ↑n → IsPreprimitive ↥(fixingSubgroup M s) ↥(SubMulAction.ofFixingSubgroup M s) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.left
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ IsMultiplyPretransitive M α n
case inr.right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ ∀ (s : Set α), Set.encard s + 1 = ↑n → IsPreprimitive ↥(fixingSubgroup M s) ↥(SubMulAction.ofFixingSubgroup M s)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_multiply_pretransitive_succ | [256, 1] | [276, 46] | exact Nat.le_succ n | case inr.left.hmn
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ n ≤ Nat.succ n
case inr.left.hα
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ ↑(Nat.succ n) ≤ PartENat.card α
case inr.right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ ∀ (s : Set α), Set.encard s + 1 = ↑n → IsPreprimitive ↥(fixingSubgroup M s) ↥(SubMulAction.ofFixingSubgroup M s) | case inr.left.hα
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ ↑(Nat.succ n) ≤ PartENat.card α
case inr.right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ ∀ (s : Set α), Set.encard s + 1 = ↑n → IsPreprimitive ↥(fixingSubgroup M s) ↥(SubMulAction.ofFixingSubgroup M s) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.left.hmn
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ n ≤ Nat.succ n
case inr.left.hα
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ ↑(Nat.succ n) ≤ PartENat.card α
case inr.right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ ∀ (s : Set α), Set.encard s + 1 = ↑n → IsPreprimitive ↥(fixingSubgroup M s) ↥(SubMulAction.ofFixingSubgroup M s)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_multiply_pretransitive_succ | [256, 1] | [276, 46] | exact hα | case inr.left.hα
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ ↑(Nat.succ n) ≤ PartENat.card α
case inr.right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ ∀ (s : Set α), Set.encard s + 1 = ↑n → IsPreprimitive ↥(fixingSubgroup M s) ↥(SubMulAction.ofFixingSubgroup M s) | case inr.right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ ∀ (s : Set α), Set.encard s + 1 = ↑n → IsPreprimitive ↥(fixingSubgroup M s) ↥(SubMulAction.ofFixingSubgroup M s) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.left.hα
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ ↑(Nat.succ n) ≤ PartENat.card α
case inr.right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ ∀ (s : Set α), Set.encard s + 1 = ↑n → IsPreprimitive ↥(fixingSubgroup M s) ↥(SubMulAction.ofFixingSubgroup M s)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_multiply_pretransitive_succ | [256, 1] | [276, 46] | obtain ⟨m, hm⟩ := Nat.exists_eq_add_of_le hn | case inr.right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ ∀ (s : Set α), Set.encard s + 1 = ↑n → IsPreprimitive ↥(fixingSubgroup M s) ↥(SubMulAction.ofFixingSubgroup M s) | case inr.right.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
⊢ ∀ (s : Set α), Set.encard s + 1 = ↑n → IsPreprimitive ↥(fixingSubgroup M s) ↥(SubMulAction.ofFixingSubgroup M s) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
⊢ ∀ (s : Set α), Set.encard s + 1 = ↑n → IsPreprimitive ↥(fixingSubgroup M s) ↥(SubMulAction.ofFixingSubgroup M s)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_multiply_pretransitive_succ | [256, 1] | [276, 46] | rw [hm] | case inr.right.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
⊢ ∀ (s : Set α), Set.encard s + 1 = ↑n → IsPreprimitive ↥(fixingSubgroup M s) ↥(SubMulAction.ofFixingSubgroup M s) | case inr.right.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
⊢ ∀ (s : Set α),
Set.encard s + 1 = ↑(Nat.succ 0 + m) → IsPreprimitive ↥(fixingSubgroup M s) ↥(SubMulAction.ofFixingSubgroup M s) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.right.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
⊢ ∀ (s : Set α), Set.encard s + 1 = ↑n → IsPreprimitive ↥(fixingSubgroup M s) ↥(SubMulAction.ofFixingSubgroup M s)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_multiply_pretransitive_succ | [256, 1] | [276, 46] | intro s hs | case inr.right.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
⊢ ∀ (s : Set α),
Set.encard s + 1 = ↑(Nat.succ 0 + m) → IsPreprimitive ↥(fixingSubgroup M s) ↥(SubMulAction.ofFixingSubgroup M s) | case inr.right.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
s : Set α
hs : Set.encard s + 1 = ↑(Nat.succ 0 + m)
⊢ IsPreprimitive ↥(fixingSubgroup M s) ↥(SubMulAction.ofFixingSubgroup M s) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.right.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
⊢ ∀ (s : Set α),
Set.encard s + 1 = ↑(Nat.succ 0 + m) → IsPreprimitive ↥(fixingSubgroup M s) ↥(SubMulAction.ofFixingSubgroup M s)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_multiply_pretransitive_succ | [256, 1] | [276, 46] | apply IsMultiplyPretransitive.isPreprimitive_of_two | case inr.right.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
s : Set α
hs : Set.encard s + 1 = ↑(Nat.succ 0 + m)
⊢ IsPreprimitive ↥(fixingSubgroup M s) ↥(SubMulAction.ofFixingSubgroup M s) | case inr.right.intro.h2
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
s : Set α
hs : Set.encard s + 1 = ↑(Nat.succ 0 + m)
⊢ IsMultiplyPretransitive (↥(fixingSubgroup M s)) (↥(SubMulAction.ofFixingSubgroup M s)) 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.right.intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
s : Set α
hs : Set.encard s + 1 = ↑(Nat.succ 0 + m)
⊢ IsPreprimitive ↥(fixingSubgroup M s) ↥(SubMulAction.ofFixingSubgroup M s)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_multiply_pretransitive_succ | [256, 1] | [276, 46] | rw [add_comm _ m, Nat.cast_add, ← Nat.cast_one, WithTop.add_eq_add_iff] at hs | case inr.right.intro.h2
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
s : Set α
hs : Set.encard s + 1 = ↑(Nat.succ 0 + m)
⊢ IsMultiplyPretransitive (↥(fixingSubgroup M s)) (↥(SubMulAction.ofFixingSubgroup M s)) 2 | case inr.right.intro.h2
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
s : Set α
hs : Set.encard s = ↑m
⊢ IsMultiplyPretransitive (↥(fixingSubgroup M s)) (↥(SubMulAction.ofFixingSubgroup M s)) 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.right.intro.h2
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
s : Set α
hs : Set.encard s + 1 = ↑(Nat.succ 0 + m)
⊢ IsMultiplyPretransitive (↥(fixingSubgroup M s)) (↥(SubMulAction.ofFixingSubgroup M s)) 2
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_multiply_pretransitive_succ | [256, 1] | [276, 46] | have : Finite s := by rw [Set.finite_coe_iff]; exact Set.finite_of_encard_eq_coe hs | case inr.right.intro.h2
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
s : Set α
hs : Set.encard s = ↑m
⊢ IsMultiplyPretransitive (↥(fixingSubgroup M s)) (↥(SubMulAction.ofFixingSubgroup M s)) 2 | case inr.right.intro.h2
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
s : Set α
hs : Set.encard s = ↑m
this : Finite ↑s
⊢ IsMultiplyPretransitive (↥(fixingSubgroup M s)) (↥(SubMulAction.ofFixingSubgroup M s)) 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.right.intro.h2
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
s : Set α
hs : Set.encard s = ↑m
⊢ IsMultiplyPretransitive (↥(fixingSubgroup M s)) (↥(SubMulAction.ofFixingSubgroup M s)) 2
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_multiply_pretransitive_succ | [256, 1] | [276, 46] | apply remaining_transitivity M α s h | case inr.right.intro.h2
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
s : Set α
hs : Set.encard s = ↑m
this : Finite ↑s
⊢ IsMultiplyPretransitive (↥(fixingSubgroup M s)) (↥(SubMulAction.ofFixingSubgroup M s)) 2 | case inr.right.intro.h2
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
s : Set α
hs : Set.encard s = ↑m
this : Finite ↑s
⊢ Nat.succ n = 2 + Set.ncard s | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.right.intro.h2
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
s : Set α
hs : Set.encard s = ↑m
this : Finite ↑s
⊢ IsMultiplyPretransitive (↥(fixingSubgroup M s)) (↥(SubMulAction.ofFixingSubgroup M s)) 2
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_multiply_pretransitive_succ | [256, 1] | [276, 46] | unfold Set.ncard | case inr.right.intro.h2
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
s : Set α
hs : Set.encard s = ↑m
this : Finite ↑s
⊢ Nat.succ n = 2 + Set.ncard s | case inr.right.intro.h2
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
s : Set α
hs : Set.encard s = ↑m
this : Finite ↑s
⊢ Nat.succ n = 2 + ENat.toNat (Set.encard s) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.right.intro.h2
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
s : Set α
hs : Set.encard s = ↑m
this : Finite ↑s
⊢ Nat.succ n = 2 + Set.ncard s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_multiply_pretransitive_succ | [256, 1] | [276, 46] | rw [hs, hm, ENat.toNat_coe, ← Nat.succ_add] | case inr.right.intro.h2
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
s : Set α
hs : Set.encard s = ↑m
this : Finite ↑s
⊢ Nat.succ n = 2 + ENat.toNat (Set.encard s) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.right.intro.h2
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
s : Set α
hs : Set.encard s = ↑m
this : Finite ↑s
⊢ Nat.succ n = 2 + ENat.toNat (Set.encard s)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_multiply_pretransitive_succ | [256, 1] | [276, 46] | rw [hn] | case inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n = 0
⊢ IsMultiplyPreprimitive M α n | case inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n = 0
⊢ IsMultiplyPreprimitive M α 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n = 0
⊢ IsMultiplyPreprimitive M α n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_multiply_pretransitive_succ | [256, 1] | [276, 46] | apply isMultiplyPreprimitive_zero | case inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n = 0
⊢ IsMultiplyPreprimitive M α 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n = 0
⊢ IsMultiplyPreprimitive M α 0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_multiply_pretransitive_succ | [256, 1] | [276, 46] | rw [Set.finite_coe_iff] | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
s : Set α
hs : Set.encard s = ↑m
⊢ Finite ↑s | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
s : Set α
hs : Set.encard s = ↑m
⊢ Set.Finite s | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
s : Set α
hs : Set.encard s = ↑m
⊢ Finite ↑s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_multiply_pretransitive_succ | [256, 1] | [276, 46] | exact Set.finite_of_encard_eq_coe hs | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
s : Set α
hs : Set.encard s = ↑m
⊢ Set.Finite 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 α
n : ℕ
hα : ↑(Nat.succ n) ≤ PartENat.card α
h : IsMultiplyPretransitive M α (Nat.succ n)
hn : n > 0
m : ℕ
hm : n = Nat.succ 0 + m
s : Set α
hs : Set.encard s = ↑m
⊢ Set.Finite s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_higher | [280, 1] | [298, 81] | induction' n with n hrec | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
n m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α n
⊢ IsMultiplyPreprimitive M α m | case zero
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m : ℕ
hmn : m ≤ Nat.zero
hα : ↑Nat.zero ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α Nat.zero
⊢ IsMultiplyPreprimitive M α m
case succ
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
⊢ IsMultiplyPreprimitive M α 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 α
n m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α n
⊢ IsMultiplyPreprimitive M α m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_higher | [280, 1] | [298, 81] | simp only [Nat.zero_eq, nonpos_iff_eq_zero] at hmn | case zero
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m : ℕ
hmn : m ≤ Nat.zero
hα : ↑Nat.zero ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α Nat.zero
⊢ IsMultiplyPreprimitive M α m | case zero
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m : ℕ
hα : ↑Nat.zero ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α Nat.zero
hmn : m = 0
⊢ IsMultiplyPreprimitive M α 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 α
m : ℕ
hmn : m ≤ Nat.zero
hα : ↑Nat.zero ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α Nat.zero
⊢ IsMultiplyPreprimitive M α m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_higher | [280, 1] | [298, 81] | rw [hmn] | case zero
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m : ℕ
hα : ↑Nat.zero ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α Nat.zero
hmn : m = 0
⊢ IsMultiplyPreprimitive M α m | case zero
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m : ℕ
hα : ↑Nat.zero ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α Nat.zero
hmn : m = 0
⊢ IsMultiplyPreprimitive M α 0 | 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 α
m : ℕ
hα : ↑Nat.zero ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α Nat.zero
hmn : m = 0
⊢ IsMultiplyPreprimitive M α m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_higher | [280, 1] | [298, 81] | apply isMultiplyPreprimitive_zero | case zero
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m : ℕ
hα : ↑Nat.zero ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α Nat.zero
hmn : m = 0
⊢ IsMultiplyPreprimitive M α 0 | 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 α
m : ℕ
hα : ↑Nat.zero ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α Nat.zero
hmn : m = 0
⊢ IsMultiplyPreprimitive M α 0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_higher | [280, 1] | [298, 81] | cases' Nat.eq_or_lt_of_le hmn with hmn hmn' | case succ
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
⊢ IsMultiplyPreprimitive M α m | case succ.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn✝ : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn : m = Nat.succ n
⊢ IsMultiplyPreprimitive M α m
case succ.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn' : m < Nat.succ n
⊢ IsMultiplyPreprimitive M α m | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
⊢ IsMultiplyPreprimitive M α m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_higher | [280, 1] | [298, 81] | rw [hmn] | case succ.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn✝ : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn : m = Nat.succ n
⊢ IsMultiplyPreprimitive M α m | case succ.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn✝ : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn : m = Nat.succ n
⊢ IsMultiplyPreprimitive M α (Nat.succ n) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn✝ : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn : m = Nat.succ n
⊢ IsMultiplyPreprimitive M α m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_higher | [280, 1] | [298, 81] | exact hn | case succ.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn✝ : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn : m = Nat.succ n
⊢ IsMultiplyPreprimitive M α (Nat.succ n) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.inl
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn✝ : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn : m = Nat.succ n
⊢ IsMultiplyPreprimitive M α (Nat.succ n)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_higher | [280, 1] | [298, 81] | apply hrec (Nat.lt_succ_iff.mp hmn') | case succ.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn' : m < Nat.succ n
⊢ IsMultiplyPreprimitive M α m | case succ.inr.hα
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn' : m < Nat.succ n
⊢ ↑n ≤ PartENat.card α
case succ.inr.hn
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn' : m < Nat.succ n
⊢ IsMultiplyPreprimitive M α n | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.inr
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn' : m < Nat.succ n
⊢ IsMultiplyPreprimitive M α m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_higher | [280, 1] | [298, 81] | refine' le_trans _ hα | case succ.inr.hα
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn' : m < Nat.succ n
⊢ ↑n ≤ PartENat.card α
case succ.inr.hn
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn' : m < Nat.succ n
⊢ IsMultiplyPreprimitive M α n | case succ.inr.hα
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn' : m < Nat.succ n
⊢ ↑n ≤ ↑(Nat.succ n)
case succ.inr.hn
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn' : m < Nat.succ n
⊢ IsMultiplyPreprimitive M α n | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.inr.hα
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn' : m < Nat.succ n
⊢ ↑n ≤ PartENat.card α
case succ.inr.hn
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn' : m < Nat.succ n
⊢ IsMultiplyPreprimitive M α n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_higher | [280, 1] | [298, 81] | rw [PartENat.coe_le_coe] | case succ.inr.hα
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn' : m < Nat.succ n
⊢ ↑n ≤ ↑(Nat.succ n)
case succ.inr.hn
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn' : m < Nat.succ n
⊢ IsMultiplyPreprimitive M α n | case succ.inr.hα
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn' : m < Nat.succ n
⊢ n ≤ Nat.succ n
case succ.inr.hn
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn' : m < Nat.succ n
⊢ IsMultiplyPreprimitive M α n | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.inr.hα
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn' : m < Nat.succ n
⊢ ↑n ≤ ↑(Nat.succ n)
case succ.inr.hn
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn' : m < Nat.succ n
⊢ IsMultiplyPreprimitive M α n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_higher | [280, 1] | [298, 81] | exact Nat.le_succ n | case succ.inr.hα
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn' : m < Nat.succ n
⊢ n ≤ Nat.succ n
case succ.inr.hn
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn' : m < Nat.succ n
⊢ IsMultiplyPreprimitive M α n | case succ.inr.hn
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn' : m < Nat.succ n
⊢ IsMultiplyPreprimitive M α n | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.inr.hα
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn' : m < Nat.succ n
⊢ n ≤ Nat.succ n
case succ.inr.hn
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn' : m < Nat.succ n
⊢ IsMultiplyPreprimitive M α n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_higher | [280, 1] | [298, 81] | apply isMultiplyPreprimitive_of_multiply_pretransitive_succ M α hα hn.left | case succ.inr.hn
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn' : m < Nat.succ n
⊢ IsMultiplyPreprimitive M α n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.inr.hn
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
m n : ℕ
hrec : m ≤ n → ↑n ≤ PartENat.card α → IsMultiplyPreprimitive M α n → IsMultiplyPreprimitive M α m
hmn : m ≤ Nat.succ n
hα : ↑(Nat.succ n) ≤ PartENat.card α
hn : IsMultiplyPreprimitive M α (Nat.succ n)
hmn' : m < Nat.succ n
⊢ IsMultiplyPreprimitive M α n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | constructor | M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
⊢ IsMultiplyPreprimitive N β n | case left
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
⊢ IsMultiplyPretransitive N β n
case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
⊢ ∀ (s : Set β), Set.encard s + 1 = ↑n → IsPreprimitive ↥(fixingSubgroup N s) ↥(SubMulAction.ofFixingSubgroup N s) | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
⊢ IsMultiplyPreprimitive N β n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | apply isMultiplyPretransitive_of_surjective_map hf.surjective h.left | case left
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
⊢ IsMultiplyPretransitive N β n
case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
⊢ ∀ (s : Set β), Set.encard s + 1 = ↑n → IsPreprimitive ↥(fixingSubgroup N s) ↥(SubMulAction.ofFixingSubgroup N s) | case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
⊢ ∀ (s : Set β), Set.encard s + 1 = ↑n → IsPreprimitive ↥(fixingSubgroup N s) ↥(SubMulAction.ofFixingSubgroup N s) | Please generate a tactic in lean4 to solve the state.
STATE:
case left
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
⊢ IsMultiplyPretransitive N β n
case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
⊢ ∀ (s : Set β), Set.encard s + 1 = ↑n → IsPreprimitive ↥(fixingSubgroup N s) ↥(SubMulAction.ofFixingSubgroup N s)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | intro t ht | case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
⊢ ∀ (s : Set β), Set.encard s + 1 = ↑n → IsPreprimitive ↥(fixingSubgroup N s) ↥(SubMulAction.ofFixingSubgroup N s) | case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
⊢ IsPreprimitive ↥(fixingSubgroup N t) ↥(SubMulAction.ofFixingSubgroup N t) | Please generate a tactic in lean4 to solve the state.
STATE:
case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
⊢ ∀ (s : Set β), Set.encard s + 1 = ↑n → IsPreprimitive ↥(fixingSubgroup N s) ↥(SubMulAction.ofFixingSubgroup N s)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | let s := f ⁻¹' t | case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
⊢ IsPreprimitive ↥(fixingSubgroup N t) ↥(SubMulAction.ofFixingSubgroup N t) | case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
⊢ IsPreprimitive ↥(fixingSubgroup N t) ↥(SubMulAction.ofFixingSubgroup N t) | Please generate a tactic in lean4 to solve the state.
STATE:
case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
⊢ IsPreprimitive ↥(fixingSubgroup N t) ↥(SubMulAction.ofFixingSubgroup N t)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | have hs' : f '' s = t := Set.image_preimage_eq t hf.surjective | case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
⊢ IsPreprimitive ↥(fixingSubgroup N t) ↥(SubMulAction.ofFixingSubgroup N t) | case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
⊢ IsPreprimitive ↥(fixingSubgroup N t) ↥(SubMulAction.ofFixingSubgroup N t) | Please generate a tactic in lean4 to solve the state.
STATE:
case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
⊢ IsPreprimitive ↥(fixingSubgroup N t) ↥(SubMulAction.ofFixingSubgroup N t)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | let φ' : fixingSubgroup M s → fixingSubgroup N t := fun ⟨m, hm⟩ =>
⟨φ m, fun ⟨y, hy⟩ => by
rw [← hs', Set.mem_image_iff_bex] at hy
obtain ⟨x, hx, hx'⟩ := hy
simp only [Subtype.coe_mk]
rw [← hx', ← map_smulₛₗ]
apply congr_arg
rw [mem_fixingSubgroup_iff] at hm
exact hm x hx⟩ | case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
⊢ IsPreprimitive ↥(fixingSubgroup N t) ↥(SubMulAction.ofFixingSubgroup N t) | case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
⊢ IsPreprimitive ↥(fixingSubgroup N t) ↥(SubMulAction.ofFixingSubgroup N t) | Please generate a tactic in lean4 to solve the state.
STATE:
case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
⊢ IsPreprimitive ↥(fixingSubgroup N t) ↥(SubMulAction.ofFixingSubgroup N t)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | let f' : SubMulAction.ofFixingSubgroup M s →ₑ[φ'] SubMulAction.ofFixingSubgroup N t :=
{ toFun := fun ⟨x, hx⟩ => ⟨f.toFun x, fun h => hx (Set.mem_preimage.mp h)⟩
map_smul' := fun ⟨m, hm⟩ ⟨x, hx⟩ =>
by
rw [← SetLike.coe_eq_coe]
exact f.map_smul' m x } | case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
⊢ IsPreprimitive ↥(fixingSubgroup N t) ↥(SubMulAction.ofFixingSubgroup N t) | case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
⊢ IsPreprimitive ↥(fixingSubgroup N t) ↥(SubMulAction.ofFixingSubgroup N t) | Please generate a tactic in lean4 to solve the state.
STATE:
case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
⊢ IsPreprimitive ↥(fixingSubgroup N t) ↥(SubMulAction.ofFixingSubgroup N t)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | refine isPreprimitive_of_surjective_map hf' (h.right s ?_) | case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
hf' : Function.Surjective ⇑f'
⊢ IsPreprimitive ↥(fixingSubgroup N t) ↥(SubMulAction.ofFixingSubgroup N t) | case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
hf' : Function.Surjective ⇑f'
⊢ Set.encard s + 1 = ↑n | Please generate a tactic in lean4 to solve the state.
STATE:
case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
hf' : Function.Surjective ⇑f'
⊢ IsPreprimitive ↥(fixingSubgroup N t) ↥(SubMulAction.ofFixingSubgroup N t)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | rw [← ht, ← hs', hf.injective.encard_image] | case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
hf' : Function.Surjective ⇑f'
⊢ Set.encard s + 1 = ↑n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
hf' : Function.Surjective ⇑f'
⊢ Set.encard s + 1 = ↑n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | rw [← hs', Set.mem_image_iff_bex] at hy | M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
x✝¹ : ↥(fixingSubgroup M s)
m : M
hm : m ∈ fixingSubgroup M s
x✝ : ↑t
y : β
hy : y ∈ t
⊢ φ m • ↑{ val := y, property := hy } = ↑{ val := y, property := hy } | M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
x✝¹ : ↥(fixingSubgroup M s)
m : M
hm : m ∈ fixingSubgroup M s
x✝ : ↑t
y : β
hy✝ : y ∈ t
hy : ∃ x, ∃ (_ : x ∈ s), f x = y
⊢ φ m • ↑{ val := y, property := hy✝ } = ↑{ val := y, property := hy✝ } | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
x✝¹ : ↥(fixingSubgroup M s)
m : M
hm : m ∈ fixingSubgroup M s
x✝ : ↑t
y : β
hy : y ∈ t
⊢ φ m • ↑{ val := y, property := hy } = ↑{ val := y, property := hy }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | obtain ⟨x, hx, hx'⟩ := hy | M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
x✝¹ : ↥(fixingSubgroup M s)
m : M
hm : m ∈ fixingSubgroup M s
x✝ : ↑t
y : β
hy✝ : y ∈ t
hy : ∃ x, ∃ (_ : x ∈ s), f x = y
⊢ φ m • ↑{ val := y, property := hy✝ } = ↑{ val := y, property := hy✝ } | case intro.intro
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
x✝¹ : ↥(fixingSubgroup M s)
m : M
hm : m ∈ fixingSubgroup M s
x✝ : ↑t
y : β
hy : y ∈ t
x : α
hx : x ∈ s
hx' : f x = y
⊢ φ m • ↑{ val := y, property := hy } = ↑{ val := y, property := hy } | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
x✝¹ : ↥(fixingSubgroup M s)
m : M
hm : m ∈ fixingSubgroup M s
x✝ : ↑t
y : β
hy✝ : y ∈ t
hy : ∃ x, ∃ (_ : x ∈ s), f x = y
⊢ φ m • ↑{ val := y, property := hy✝ } = ↑{ val := y, property := hy✝ }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | simp only [Subtype.coe_mk] | case intro.intro
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
x✝¹ : ↥(fixingSubgroup M s)
m : M
hm : m ∈ fixingSubgroup M s
x✝ : ↑t
y : β
hy : y ∈ t
x : α
hx : x ∈ s
hx' : f x = y
⊢ φ m • ↑{ val := y, property := hy } = ↑{ val := y, property := hy } | case intro.intro
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
x✝¹ : ↥(fixingSubgroup M s)
m : M
hm : m ∈ fixingSubgroup M s
x✝ : ↑t
y : β
hy : y ∈ t
x : α
hx : x ∈ s
hx' : f x = y
⊢ φ m • y = y | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
x✝¹ : ↥(fixingSubgroup M s)
m : M
hm : m ∈ fixingSubgroup M s
x✝ : ↑t
y : β
hy : y ∈ t
x : α
hx : x ∈ s
hx' : f x = y
⊢ φ m • ↑{ val := y, property := hy } = ↑{ val := y, property := hy }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | rw [← hx', ← map_smulₛₗ] | case intro.intro
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
x✝¹ : ↥(fixingSubgroup M s)
m : M
hm : m ∈ fixingSubgroup M s
x✝ : ↑t
y : β
hy : y ∈ t
x : α
hx : x ∈ s
hx' : f x = y
⊢ φ m • y = y | case intro.intro
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
x✝¹ : ↥(fixingSubgroup M s)
m : M
hm : m ∈ fixingSubgroup M s
x✝ : ↑t
y : β
hy : y ∈ t
x : α
hx : x ∈ s
hx' : f x = y
⊢ f (m • x) = f x | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
x✝¹ : ↥(fixingSubgroup M s)
m : M
hm : m ∈ fixingSubgroup M s
x✝ : ↑t
y : β
hy : y ∈ t
x : α
hx : x ∈ s
hx' : f x = y
⊢ φ m • y = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | apply congr_arg | case intro.intro
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
x✝¹ : ↥(fixingSubgroup M s)
m : M
hm : m ∈ fixingSubgroup M s
x✝ : ↑t
y : β
hy : y ∈ t
x : α
hx : x ∈ s
hx' : f x = y
⊢ f (m • x) = f x | case intro.intro.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
x✝¹ : ↥(fixingSubgroup M s)
m : M
hm : m ∈ fixingSubgroup M s
x✝ : ↑t
y : β
hy : y ∈ t
x : α
hx : x ∈ s
hx' : f x = y
⊢ m • x = x | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
x✝¹ : ↥(fixingSubgroup M s)
m : M
hm : m ∈ fixingSubgroup M s
x✝ : ↑t
y : β
hy : y ∈ t
x : α
hx : x ∈ s
hx' : f x = y
⊢ f (m • x) = f x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | rw [mem_fixingSubgroup_iff] at hm | case intro.intro.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
x✝¹ : ↥(fixingSubgroup M s)
m : M
hm : m ∈ fixingSubgroup M s
x✝ : ↑t
y : β
hy : y ∈ t
x : α
hx : x ∈ s
hx' : f x = y
⊢ m • x = x | case intro.intro.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
x✝¹ : ↥(fixingSubgroup M s)
m : M
hm : ∀ y ∈ s, m • y = y
x✝ : ↑t
y : β
hy : y ∈ t
x : α
hx : x ∈ s
hx' : f x = y
⊢ m • x = x | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
x✝¹ : ↥(fixingSubgroup M s)
m : M
hm : m ∈ fixingSubgroup M s
x✝ : ↑t
y : β
hy : y ∈ t
x : α
hx : x ∈ s
hx' : f x = y
⊢ m • x = x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | exact hm x hx | case intro.intro.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
x✝¹ : ↥(fixingSubgroup M s)
m : M
hm : ∀ y ∈ s, m • y = y
x✝ : ↑t
y : β
hy : y ∈ t
x : α
hx : x ∈ s
hx' : f x = y
⊢ m • x = x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
x✝¹ : ↥(fixingSubgroup M s)
m : M
hm : ∀ y ∈ s, m • y = y
x✝ : ↑t
y : β
hy : y ∈ t
x : α
hx : x ∈ s
hx' : f x = y
⊢ m • x = x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | rw [← SetLike.coe_eq_coe] | M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
x✝¹ : ↥(fixingSubgroup M s)
x✝ : ↥(SubMulAction.ofFixingSubgroup M s)
m : M
hm : m ∈ fixingSubgroup M s
x : α
hx : x ∈ SubMulAction.ofFixingSubgroup M s
⊢ (fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ })
({ val := m, property := hm } • { val := x, property := hx }) =
φ' { val := m, property := hm } •
(fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ })
{ val := x, property := hx } | M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
x✝¹ : ↥(fixingSubgroup M s)
x✝ : ↥(SubMulAction.ofFixingSubgroup M s)
m : M
hm : m ∈ fixingSubgroup M s
x : α
hx : x ∈ SubMulAction.ofFixingSubgroup M s
⊢ ↑((fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ })
({ val := m, property := hm } • { val := x, property := hx })) =
↑(φ' { val := m, property := hm } •
(fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ })
{ val := x, property := hx }) | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
x✝¹ : ↥(fixingSubgroup M s)
x✝ : ↥(SubMulAction.ofFixingSubgroup M s)
m : M
hm : m ∈ fixingSubgroup M s
x : α
hx : x ∈ SubMulAction.ofFixingSubgroup M s
⊢ (fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ })
({ val := m, property := hm } • { val := x, property := hx }) =
φ' { val := m, property := hm } •
(fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ })
{ val := x, property := hx }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | exact f.map_smul' m x | M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
x✝¹ : ↥(fixingSubgroup M s)
x✝ : ↥(SubMulAction.ofFixingSubgroup M s)
m : M
hm : m ∈ fixingSubgroup M s
x : α
hx : x ∈ SubMulAction.ofFixingSubgroup M s
⊢ ↑((fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ })
({ val := m, property := hm } • { val := x, property := hx })) =
↑(φ' { val := m, property := hm } •
(fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ })
{ val := x, property := hx }) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
x✝¹ : ↥(fixingSubgroup M s)
x✝ : ↥(SubMulAction.ofFixingSubgroup M s)
m : M
hm : m ∈ fixingSubgroup M s
x : α
hx : x ∈ SubMulAction.ofFixingSubgroup M s
⊢ ↑((fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ })
({ val := m, property := hm } • { val := x, property := hx })) =
↑(φ' { val := m, property := hm } •
(fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ })
{ val := x, property := hx })
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | rintro ⟨y, hy⟩ | M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
⊢ Function.Surjective ⇑f' | case mk
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
⊢ ∃ a, f' a = { val := y, property := hy } | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
⊢ Function.Surjective ⇑f'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | obtain ⟨x, hx⟩ := hf.right y | case mk
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
⊢ ∃ a, f' a = { val := y, property := hy } | case mk.intro
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
x : α
hx : f x = y
⊢ ∃ a, f' a = { val := y, property := hy } | Please generate a tactic in lean4 to solve the state.
STATE:
case mk
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
⊢ ∃ a, f' a = { val := y, property := hy }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | use ⟨x, ?_⟩ | case mk.intro
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
x : α
hx : f x = y
⊢ ∃ a, f' a = { val := y, property := hy } | case h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
x : α
hx : f x = y
⊢ f' { val := x, property := ?w } = { val := y, property := hy }
case w
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
x : α
hx : f x = y
⊢ x ∈ SubMulAction.ofFixingSubgroup M s | Please generate a tactic in lean4 to solve the state.
STATE:
case mk.intro
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
x : α
hx : f x = y
⊢ ∃ a, f' a = { val := y, property := hy }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | simp only [f'] | case h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
x : α
hx : f x = y
⊢ f' { val := x, property := ?w } = { val := y, property := hy } | case h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
x : α
hx : f x = y
⊢ { toFun := fun x => { val := f.toFun ↑x, property := ⋯ }, map_smul' := ⋯ } { val := x, property := ?w } =
{ val := y, property := hy } | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
x : α
hx : f x = y
⊢ f' { val := x, property := ?w } = { val := y, property := hy }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | apply Subtype.coe_injective | case h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
x : α
hx : f x = y
⊢ { toFun := fun x => { val := f.toFun ↑x, property := ⋯ }, map_smul' := ⋯ } { val := x, property := ?w } =
{ val := y, property := hy } | case h.a
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
x : α
hx : f x = y
⊢ (fun a => ↑a)
({ toFun := fun x => { val := f.toFun ↑x, property := ⋯ }, map_smul' := ⋯ } { val := x, property := ?w }) =
(fun a => ↑a) { val := y, property := hy } | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
x : α
hx : f x = y
⊢ { toFun := fun x => { val := f.toFun ↑x, property := ⋯ }, map_smul' := ⋯ } { val := x, property := ?w } =
{ val := y, property := hy }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | exact hx | case h.a
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
x : α
hx : f x = y
⊢ (fun a => ↑a)
({ toFun := fun x => { val := f.toFun ↑x, property := ⋯ }, map_smul' := ⋯ } { val := x, property := ?w }) =
(fun a => ↑a) { val := y, property := hy } | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.a
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
x : α
hx : f x = y
⊢ (fun a => ↑a)
({ toFun := fun x => { val := f.toFun ↑x, property := ⋯ }, map_smul' := ⋯ } { val := x, property := ?w }) =
(fun a => ↑a) { val := y, property := hy }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | intro h | case w
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
x : α
hx : f x = y
⊢ x ∈ SubMulAction.ofFixingSubgroup M s | case w
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h✝ : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
x : α
hx : f x = y
h : x ∈ s
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case w
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
x : α
hx : f x = y
⊢ x ∈ SubMulAction.ofFixingSubgroup M s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | apply hy | case w
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h✝ : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
x : α
hx : f x = y
h : x ∈ s
⊢ False | case w
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h✝ : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
x : α
hx : f x = y
h : x ∈ s
⊢ y ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
case w
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h✝ : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
x : α
hx : f x = y
h : x ∈ s
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | rw [← hs'] | case w
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h✝ : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
x : α
hx : f x = y
h : x ∈ s
⊢ y ∈ t | case w
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h✝ : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
x : α
hx : f x = y
h : x ∈ s
⊢ y ∈ ⇑f '' s | Please generate a tactic in lean4 to solve the state.
STATE:
case w
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h✝ : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
x : α
hx : f x = y
h : x ∈ s
⊢ y ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultiplePrimitivity.lean | MulAction.isMultiplyPreprimitive_of_bijective_map | [303, 1] | [340, 46] | exact ⟨x, h, hx⟩ | case w
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h✝ : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
x : α
hx : f x = y
h : x ∈ s
⊢ y ∈ ⇑f '' s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case w
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
φ : M → N
f : α →ₑ[φ] β
hf : Function.Bijective ⇑f
n : ℕ
h✝ : IsMultiplyPreprimitive M α n
t : Set β
ht : Set.encard t + 1 = ↑n
s : Set α := ⇑f ⁻¹' t
hs' : ⇑f '' s = t
φ' : ↥(fixingSubgroup M s) → ↥(fixingSubgroup N t) :=
fun x =>
match x with
| { val := m, property := hm } => { val := φ m, property := ⋯ }
f' : ↥(SubMulAction.ofFixingSubgroup M s) →ₑ[φ'] ↥(SubMulAction.ofFixingSubgroup N t) :=
{
toFun := fun x =>
match x with
| { val := x, property := hx } => { val := f.toFun x, property := ⋯ },
map_smul' := ⋯ }
y : β
hy : y ∈ SubMulAction.ofFixingSubgroup N t
x : α
hx : f x = y
h : x ∈ s
⊢ y ∈ ⇑f '' s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.isPartition_on | [43, 1] | [66, 68] | constructor | α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
⊢ IsPartition {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ s ≠ ∅} | case left
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
⊢ ∅ ∉ {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ s ≠ ∅}
case right
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
⊢ ∀ (a : ↑s), ∃! b x, a ∈ b | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
⊢ IsPartition {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ s ≠ ∅}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.isPartition_on | [43, 1] | [66, 68] | intro h | case left
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
⊢ ∅ ∉ {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ s ≠ ∅} | case left
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
h : ∅ ∈ {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ s ≠ ∅}
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case left
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
⊢ ∅ ∉ {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ s ≠ ∅}
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.