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/Primitive.lean | isPreprimitive_of_prime | [583, 1] | [603, 38] | rw [← Nat.dvd_prime hp] | case has_trivial_blocks'.inr.h
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : Set.Nontrivial B
⊢ Set.ncard B = 1 ∨ Set.ncard B = Fintype.card α | case has_trivial_blocks'.inr.h
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : Set.Nontrivial B
⊢ Set.ncard B ∣ Fintype.card α | Please generate a tactic in lean4 to solve the state.
STATE:
case has_trivial_blocks'.inr.h
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : Set.Nontrivial B
⊢ Set.ncard B = 1 ∨ Set.ncard B = Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_prime | [583, 1] | [603, 38] | simp only [← Nat.card_eq_fintype_card] | case has_trivial_blocks'.inr.h
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : Set.Nontrivial B
⊢ Set.ncard B ∣ Fintype.card α | case has_trivial_blocks'.inr.h
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : Set.Nontrivial B
⊢ Set.ncard B ∣ Nat.card α | Please generate a tactic in lean4 to solve the state.
STATE:
case has_trivial_blocks'.inr.h
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : Set.Nontrivial B
⊢ Set.ncard B ∣ Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_prime | [583, 1] | [603, 38] | apply ncard_of_block_divides hB | case has_trivial_blocks'.inr.h
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : Set.Nontrivial B
⊢ Set.ncard B ∣ Nat.card α | case has_trivial_blocks'.inr.h
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : Set.Nontrivial B
⊢ Set.Nonempty B | Please generate a tactic in lean4 to solve the state.
STATE:
case has_trivial_blocks'.inr.h
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : Set.Nontrivial B
⊢ Set.ncard B ∣ Nat.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_prime | [583, 1] | [603, 38] | exact Set.Nontrivial.nonempty hB' | case has_trivial_blocks'.inr.h
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : Set.Nontrivial B
⊢ Set.Nonempty B | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case has_trivial_blocks'.inr.h
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : Set.Nontrivial B
⊢ Set.Nonempty B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_prime | [583, 1] | [603, 38] | cases' this with h h | M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : Set.Nontrivial B
this : Set.ncard B = 1 ∨ Set.ncard B = Fintype.card α
⊢ B = ⊤ | case inl
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : Set.Nontrivial B
h : Set.ncard B = 1
⊢ B = ⊤
case inr
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : Set.Nontrivial B
h : Set.ncard B = Fintype.card α
⊢ B = ⊤ | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : Set.Nontrivial B
this : Set.ncard B = 1 ∨ Set.ncard B = Fintype.card α
⊢ B = ⊤
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_prime | [583, 1] | [603, 38] | exfalso | case inl
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : Set.Nontrivial B
h : Set.ncard B = 1
⊢ B = ⊤ | case inl
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : Set.Nontrivial B
h : Set.ncard B = 1
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : Set.Nontrivial B
h : Set.ncard B = 1
⊢ B = ⊤
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_prime | [583, 1] | [603, 38] | rw [← Set.one_lt_ncard_iff_nontrivial, ← not_le] at hB' | case inl
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : Set.Nontrivial B
h : Set.ncard B = 1
⊢ False | case inl
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : ¬Set.ncard B ≤ 1
h : Set.ncard B = 1
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : Set.Nontrivial B
h : Set.ncard B = 1
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_prime | [583, 1] | [603, 38] | exact hB' (le_of_eq h) | case inl
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : ¬Set.ncard B ≤ 1
h : Set.ncard B = 1
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : ¬Set.ncard B ≤ 1
h : Set.ncard B = 1
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_prime | [583, 1] | [603, 38] | rw [Set.eq_top_iff_ncard] | case inr
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : Set.Nontrivial B
h : Set.ncard B = Fintype.card α
⊢ B = ⊤ | case inr
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : Set.Nontrivial B
h : Set.ncard B = Fintype.card α
⊢ Set.ncard B = Fintype.card α | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : Set.Nontrivial B
h : Set.ncard B = Fintype.card α
⊢ B = ⊤
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_prime | [583, 1] | [603, 38] | exact h | case inr
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : Set.Nontrivial B
h : Set.ncard B = Fintype.card α
⊢ Set.ncard B = Fintype.card α | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
M : Type u_2
inst✝⁴ : Group M
α : Type u_1
inst✝³ : MulAction M α
N : Type ?u.75053
β : Type ?u.75056
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype α
hGX : IsPretransitive M α
hp : Nat.Prime (Fintype.card α)
B : Set α
hB : IsBlock M B
hB' : Set.Nontrivial B
h : Set.ncard B = Fintype.card α
⊢ Set.ncard B = Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | apply IsPreprimitive.mk | M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
⊢ IsPreprimitive N β | case has_trivial_blocks'
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
⊢ ∀ {B : Set β}, IsBlock N B → IsTrivialBlock B | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
⊢ IsPreprimitive N β
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | intro B hB | case has_trivial_blocks'
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
⊢ ∀ {B : Set β}, IsBlock N B → IsTrivialBlock B | case has_trivial_blocks'
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
⊢ IsTrivialBlock B | Please generate a tactic in lean4 to solve the state.
STATE:
case has_trivial_blocks'
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
⊢ ∀ {B : Set β}, IsBlock N B → IsTrivialBlock B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | dsimp only [IsTrivialBlock] | case has_trivial_blocks'
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
⊢ IsTrivialBlock B | case has_trivial_blocks'
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
⊢ Set.Subsingleton B ∨ B = ⊤ | Please generate a tactic in lean4 to solve the state.
STATE:
case has_trivial_blocks'
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
⊢ IsTrivialBlock B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | rw [or_iff_not_imp_right] | case has_trivial_blocks'
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
⊢ Set.Subsingleton B ∨ B = ⊤ | case has_trivial_blocks'
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
⊢ ¬B = ⊤ → Set.Subsingleton B | Please generate a tactic in lean4 to solve the state.
STATE:
case has_trivial_blocks'
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
⊢ Set.Subsingleton B ∨ B = ⊤
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | intro hB_ne_top | case has_trivial_blocks'
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
⊢ ¬B = ⊤ → Set.Subsingleton B | case has_trivial_blocks'
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
⊢ Set.Subsingleton B | Please generate a tactic in lean4 to solve the state.
STATE:
case has_trivial_blocks'
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
⊢ ¬B = ⊤ → Set.Subsingleton B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | rw [Set.subsingleton_iff_ncard_le_one, ← Nat.lt_succ] | case has_trivial_blocks'
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
⊢ Set.Subsingleton B | case has_trivial_blocks'
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
⊢ Set.ncard B < Nat.succ 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case has_trivial_blocks'
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
⊢ Set.Subsingleton B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | cases' Set.eq_empty_or_nonempty B with hBe hB_ne | case has_trivial_blocks'
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
⊢ Set.ncard B < Nat.succ 1 | case has_trivial_blocks'.inl
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hBe : B = ∅
⊢ Set.ncard B < Nat.succ 1
case has_trivial_blocks'.inr
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ Set.ncard B < Nat.succ 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case has_trivial_blocks'
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
⊢ Set.ncard B < Nat.succ 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | apply lt_of_mul_lt_mul_right (lt_of_le_of_lt _ hf') (Nat.zero_le _) | case has_trivial_blocks'.inr
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ Set.ncard B < Nat.succ 1 | M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ Set.ncard B * Set.ncard (Set.range ⇑f) ≤ Fintype.card β | Please generate a tactic in lean4 to solve the state.
STATE:
case has_trivial_blocks'.inr
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ Set.ncard B < Nat.succ 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | simp only [← Nat.card_eq_fintype_card, ← ncard_block_mul_ncard_orbit_eq hB hB_ne] | M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ Set.ncard B * Set.ncard (Set.range ⇑f) ≤ Fintype.card β | M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ Set.ncard B * Set.ncard (Set.range ⇑f) ≤ Set.ncard B * Set.ncard (Set.range fun g => g • B) | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ Set.ncard B * Set.ncard (Set.range ⇑f) ≤ Fintype.card β
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | apply Nat.mul_le_mul_left _ | M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ Set.ncard B * Set.ncard (Set.range ⇑f) ≤ Set.ncard B * Set.ncard (Set.range fun g => g • B) | M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ Set.ncard (Set.range ⇑f) ≤ Set.ncard (Set.range fun g => g • B) | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ Set.ncard B * Set.ncard (Set.range ⇑f) ≤ Set.ncard B * Set.ncard (Set.range fun g => g • B)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | classical
simp only [Set.ncard_eq_toFinset_card']
rw [Setoid.IsPartition.card_set_eq_sum_parts (Set.range f)
(IsBlockSystem.of_block hB hB_ne).left]
rw [Finset.card_eq_sum_ones]
refine' Finset.sum_le_sum _
intro t ht
rw [← Set.ncard_eq_toFinset_card', ← Set.subsingleton_iff_ncard_le_one,
Set.inter_comm, ← Set.image_preimage_eq_inter_range]
apply Set.Subsingleton.image
simp only [Set.mem_toFinset, Set.mem_range] at ht
obtain ⟨g, rfl⟩ := ht
apply Or.resolve_right
(hM.has_trivial_blocks (IsBlock_preimage f (IsBlock_of_block g hB)))
intro h
apply hB_ne_top
apply is_top_of_large_block hB
rw [Nat.card_eq_fintype_card]
apply lt_of_lt_of_le hf'
simp only [mul_le_mul_left, Nat.succ_pos', ← smul_set_ncard_eq g B]
apply Set.ncard_le_ncard
rw [← Set.image_univ, Set.image_subset_iff, ← Set.top_eq_univ, h]
exact Set.toFinite (g • B) | M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ Set.ncard (Set.range ⇑f) ≤ Set.ncard (Set.range fun g => g • B) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ Set.ncard (Set.range ⇑f) ≤ Set.ncard (Set.range fun g => g • B)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | rw [hBe] | case has_trivial_blocks'.inl
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hBe : B = ∅
⊢ Set.ncard B < Nat.succ 1 | case has_trivial_blocks'.inl
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hBe : B = ∅
⊢ Set.ncard ∅ < Nat.succ 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case has_trivial_blocks'.inl
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hBe : B = ∅
⊢ Set.ncard B < Nat.succ 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | simp only [Set.ncard_empty, Nat.succ_pos'] | case has_trivial_blocks'.inl
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hBe : B = ∅
⊢ Set.ncard ∅ < Nat.succ 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case has_trivial_blocks'.inl
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hBe : B = ∅
⊢ Set.ncard ∅ < Nat.succ 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | simp only [Set.ncard_eq_toFinset_card'] | M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ Set.ncard (Set.range ⇑f) ≤ Set.ncard (Set.range fun g => g • B) | M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ (Set.toFinset (Set.range ⇑f)).card ≤ (Set.toFinset (Set.range fun g => g • B)).card | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ Set.ncard (Set.range ⇑f) ≤ Set.ncard (Set.range fun g => g • B)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | rw [Setoid.IsPartition.card_set_eq_sum_parts (Set.range f)
(IsBlockSystem.of_block hB hB_ne).left] | M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ (Set.toFinset (Set.range ⇑f)).card ≤ (Set.toFinset (Set.range fun g => g • B)).card | M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ ∑ t in Set.toFinset (Set.range fun g => g • B), (Set.toFinset (Set.range ⇑f ∩ t)).card ≤
(Set.toFinset (Set.range fun g => g • B)).card | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ (Set.toFinset (Set.range ⇑f)).card ≤ (Set.toFinset (Set.range fun g => g • B)).card
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | rw [Finset.card_eq_sum_ones] | M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ ∑ t in Set.toFinset (Set.range fun g => g • B), (Set.toFinset (Set.range ⇑f ∩ t)).card ≤
(Set.toFinset (Set.range fun g => g • B)).card | M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ ∑ t in Set.toFinset (Set.range fun g => g • B), (Set.toFinset (Set.range ⇑f ∩ t)).card ≤
∑ x in Set.toFinset (Set.range fun g => g • B), 1 | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ ∑ t in Set.toFinset (Set.range fun g => g • B), (Set.toFinset (Set.range ⇑f ∩ t)).card ≤
(Set.toFinset (Set.range fun g => g • B)).card
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | refine' Finset.sum_le_sum _ | M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ ∑ t in Set.toFinset (Set.range fun g => g • B), (Set.toFinset (Set.range ⇑f ∩ t)).card ≤
∑ x in Set.toFinset (Set.range fun g => g • B), 1 | M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ ∀ i ∈ Set.toFinset (Set.range fun g => g • B), (Set.toFinset (Set.range ⇑f ∩ i)).card ≤ 1 | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ ∑ t in Set.toFinset (Set.range fun g => g • B), (Set.toFinset (Set.range ⇑f ∩ t)).card ≤
∑ x in Set.toFinset (Set.range fun g => g • B), 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | intro t ht | M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ ∀ i ∈ Set.toFinset (Set.range fun g => g • B), (Set.toFinset (Set.range ⇑f ∩ i)).card ≤ 1 | M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
t : Set β
ht : t ∈ Set.toFinset (Set.range fun g => g • B)
⊢ (Set.toFinset (Set.range ⇑f ∩ t)).card ≤ 1 | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
⊢ ∀ i ∈ Set.toFinset (Set.range fun g => g • B), (Set.toFinset (Set.range ⇑f ∩ i)).card ≤ 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | rw [← Set.ncard_eq_toFinset_card', ← Set.subsingleton_iff_ncard_le_one,
Set.inter_comm, ← Set.image_preimage_eq_inter_range] | M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
t : Set β
ht : t ∈ Set.toFinset (Set.range fun g => g • B)
⊢ (Set.toFinset (Set.range ⇑f ∩ t)).card ≤ 1 | M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
t : Set β
ht : t ∈ Set.toFinset (Set.range fun g => g • B)
⊢ Set.Subsingleton (⇑f '' (⇑f ⁻¹' t)) | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
t : Set β
ht : t ∈ Set.toFinset (Set.range fun g => g • B)
⊢ (Set.toFinset (Set.range ⇑f ∩ t)).card ≤ 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | apply Set.Subsingleton.image | M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
t : Set β
ht : t ∈ Set.toFinset (Set.range fun g => g • B)
⊢ Set.Subsingleton (⇑f '' (⇑f ⁻¹' t)) | case hs
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
t : Set β
ht : t ∈ Set.toFinset (Set.range fun g => g • B)
⊢ Set.Subsingleton (⇑f ⁻¹' t) | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
t : Set β
ht : t ∈ Set.toFinset (Set.range fun g => g • B)
⊢ Set.Subsingleton (⇑f '' (⇑f ⁻¹' t))
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | simp only [Set.mem_toFinset, Set.mem_range] at ht | case hs
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
t : Set β
ht : t ∈ Set.toFinset (Set.range fun g => g • B)
⊢ Set.Subsingleton (⇑f ⁻¹' t) | case hs
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
t : Set β
ht : ∃ y, y • B = t
⊢ Set.Subsingleton (⇑f ⁻¹' t) | Please generate a tactic in lean4 to solve the state.
STATE:
case hs
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
t : Set β
ht : t ∈ Set.toFinset (Set.range fun g => g • B)
⊢ Set.Subsingleton (⇑f ⁻¹' t)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | obtain ⟨g, rfl⟩ := ht | case hs
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
t : Set β
ht : ∃ y, y • B = t
⊢ Set.Subsingleton (⇑f ⁻¹' t) | case hs.intro
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
⊢ Set.Subsingleton (⇑f ⁻¹' (g • B)) | Please generate a tactic in lean4 to solve the state.
STATE:
case hs
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
t : Set β
ht : ∃ y, y • B = t
⊢ Set.Subsingleton (⇑f ⁻¹' t)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | apply Or.resolve_right
(hM.has_trivial_blocks (IsBlock_preimage f (IsBlock_of_block g hB))) | case hs.intro
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
⊢ Set.Subsingleton (⇑f ⁻¹' (g • B)) | case hs.intro
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
⊢ ¬⇑f ⁻¹' (g • B) = ⊤ | Please generate a tactic in lean4 to solve the state.
STATE:
case hs.intro
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
⊢ Set.Subsingleton (⇑f ⁻¹' (g • B))
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | intro h | case hs.intro
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
⊢ ¬⇑f ⁻¹' (g • B) = ⊤ | case hs.intro
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case hs.intro
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
⊢ ¬⇑f ⁻¹' (g • B) = ⊤
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | apply hB_ne_top | case hs.intro
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ False | case hs.intro
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ B = ⊤ | Please generate a tactic in lean4 to solve the state.
STATE:
case hs.intro
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | apply is_top_of_large_block hB | case hs.intro
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ B = ⊤ | case hs.intro
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ Nat.card β < 2 * Set.ncard B | Please generate a tactic in lean4 to solve the state.
STATE:
case hs.intro
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ B = ⊤
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | rw [Nat.card_eq_fintype_card] | case hs.intro
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ Nat.card β < 2 * Set.ncard B | case hs.intro
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ Fintype.card β < 2 * Set.ncard B | Please generate a tactic in lean4 to solve the state.
STATE:
case hs.intro
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ Nat.card β < 2 * Set.ncard B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | apply lt_of_lt_of_le hf' | case hs.intro
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ Fintype.card β < 2 * Set.ncard B | case hs.intro
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ 2 * Set.ncard (Set.range ⇑f) ≤ 2 * Set.ncard B | Please generate a tactic in lean4 to solve the state.
STATE:
case hs.intro
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ Fintype.card β < 2 * Set.ncard B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | simp only [mul_le_mul_left, Nat.succ_pos', ← smul_set_ncard_eq g B] | case hs.intro
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ 2 * Set.ncard (Set.range ⇑f) ≤ 2 * Set.ncard B | case hs.intro
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ Set.ncard (Set.range ⇑f) ≤ Set.ncard (g • B) | Please generate a tactic in lean4 to solve the state.
STATE:
case hs.intro
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ 2 * Set.ncard (Set.range ⇑f) ≤ 2 * Set.ncard B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | apply Set.ncard_le_ncard | case hs.intro
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ Set.ncard (Set.range ⇑f) ≤ Set.ncard (g • B) | case hs.intro.hst
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ Set.range ⇑f ⊆ g • B
case hs.intro.ht
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ autoParam (Set.Finite (g • B)) _auto✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case hs.intro
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ Set.ncard (Set.range ⇑f) ≤ Set.ncard (g • B)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | rw [← Set.image_univ, Set.image_subset_iff, ← Set.top_eq_univ, h] | case hs.intro.hst
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ Set.range ⇑f ⊆ g • B
case hs.intro.ht
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ autoParam (Set.Finite (g • B)) _auto✝ | case hs.intro.ht
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ autoParam (Set.Finite (g • B)) _auto✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case hs.intro.hst
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ Set.range ⇑f ⊆ g • B
case hs.intro.ht
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ autoParam (Set.Finite (g • B)) _auto✝
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | isPreprimitive_of_large_image | [685, 1] | [751, 29] | exact Set.toFinite (g • B) | case hs.intro.ht
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ autoParam (Set.Finite (g • B)) _auto✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case hs.intro.ht
M : Type u_4
inst✝⁴ : Group M
α : Type u_3
inst✝³ : MulAction M α
N : Type u_2
β : Type u_1
inst✝² : Group N
inst✝¹ : MulAction N β
inst✝ : Fintype β
htβ : IsPretransitive N β
φ : M → N
f : α →ₑ[φ] β
hM : IsPreprimitive M α
hf' : Fintype.card β < 2 * Set.ncard (Set.range ⇑f)
B : Set β
hB : IsBlock N B
hB_ne_top : ¬B = ⊤
hB_ne : Set.Nonempty B
g : N
h : ⇑f ⁻¹' (g • B) = ⊤
⊢ autoParam (Set.Finite (g • B)) _auto✝
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | Rudio | [754, 1] | [777, 17] | let B := ⋂ (g : M) (_ : a ∈ g • A), g • A | M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
⊢ ∃ g, a ∈ g • A ∧ b ∉ g • A | M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
⊢ ∃ g, a ∈ g • A ∧ b ∉ g • A | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
⊢ ∃ g, a ∈ g • A ∧ b ∉ g • A
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | Rudio | [754, 1] | [777, 17] | suffices b ∉ B by
rw [Set.mem_iInter] at this
simpa only [Set.mem_iInter, not_forall, exists_prop] using this | M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
⊢ ∃ g, a ∈ g • A ∧ b ∉ g • A | M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
⊢ b ∉ B | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
⊢ ∃ g, a ∈ g • A ∧ b ∉ g • A
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | Rudio | [754, 1] | [777, 17] | suffices B = {a} by rw [this]; rw [Set.mem_singleton_iff]; exact Ne.symm h | M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
⊢ b ∉ B | M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
⊢ B = {a} | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
⊢ b ∉ B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | Rudio | [754, 1] | [777, 17] | cases' hpGX.has_trivial_blocks (IsBlock.of_subset a A hfA) with hyp hyp | M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
⊢ B = {a} | case inl
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : Set.Subsingleton (⋂ k, ⋂ (_ : a ∈ k • A), k • A)
⊢ B = {a}
case inr
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : ⋂ k, ⋂ (_ : a ∈ k • A), k • A = ⊤
⊢ B = {a} | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
⊢ B = {a}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | Rudio | [754, 1] | [777, 17] | rw [Set.mem_iInter] at this | M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
this : b ∉ B
⊢ ∃ g, a ∈ g • A ∧ b ∉ g • A | M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
this : ¬∀ (i : M), b ∈ ⋂ (_ : a ∈ i • A), i • A
⊢ ∃ g, a ∈ g • A ∧ b ∉ g • A | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
this : b ∉ B
⊢ ∃ g, a ∈ g • A ∧ b ∉ g • A
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | Rudio | [754, 1] | [777, 17] | simpa only [Set.mem_iInter, not_forall, exists_prop] using this | M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
this : ¬∀ (i : M), b ∈ ⋂ (_ : a ∈ i • A), i • A
⊢ ∃ g, a ∈ g • A ∧ b ∉ g • A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
this : ¬∀ (i : M), b ∈ ⋂ (_ : a ∈ i • A), i • A
⊢ ∃ g, a ∈ g • A ∧ b ∉ g • A
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | Rudio | [754, 1] | [777, 17] | rw [this] | M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
this : B = {a}
⊢ b ∉ B | M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
this : B = {a}
⊢ b ∉ {a} | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
this : B = {a}
⊢ b ∉ B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | Rudio | [754, 1] | [777, 17] | rw [Set.mem_singleton_iff] | M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
this : B = {a}
⊢ b ∉ {a} | M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
this : B = {a}
⊢ ¬b = a | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
this : B = {a}
⊢ b ∉ {a}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | Rudio | [754, 1] | [777, 17] | exact Ne.symm h | M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
this : B = {a}
⊢ ¬b = a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
this : B = {a}
⊢ ¬b = a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | Rudio | [754, 1] | [777, 17] | apply Set.Subsingleton.eq_singleton_of_mem hyp | case inl
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : Set.Subsingleton (⋂ k, ⋂ (_ : a ∈ k • A), k • A)
⊢ B = {a} | case inl
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : Set.Subsingleton (⋂ k, ⋂ (_ : a ∈ k • A), k • A)
⊢ a ∈ ⋂ k, ⋂ (_ : a ∈ k • A), k • A | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : Set.Subsingleton (⋂ k, ⋂ (_ : a ∈ k • A), k • A)
⊢ B = {a}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | Rudio | [754, 1] | [777, 17] | rw [Set.mem_iInter] | case inl
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : Set.Subsingleton (⋂ k, ⋂ (_ : a ∈ k • A), k • A)
⊢ a ∈ ⋂ k, ⋂ (_ : a ∈ k • A), k • A | case inl
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : Set.Subsingleton (⋂ k, ⋂ (_ : a ∈ k • A), k • A)
⊢ ∀ (i : M), a ∈ ⋂ (_ : a ∈ i • A), i • A | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : Set.Subsingleton (⋂ k, ⋂ (_ : a ∈ k • A), k • A)
⊢ a ∈ ⋂ k, ⋂ (_ : a ∈ k • A), k • A
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | Rudio | [754, 1] | [777, 17] | intro g | case inl
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : Set.Subsingleton (⋂ k, ⋂ (_ : a ∈ k • A), k • A)
⊢ ∀ (i : M), a ∈ ⋂ (_ : a ∈ i • A), i • A | case inl
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : Set.Subsingleton (⋂ k, ⋂ (_ : a ∈ k • A), k • A)
g : M
⊢ a ∈ ⋂ (_ : a ∈ g • A), g • A | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : Set.Subsingleton (⋂ k, ⋂ (_ : a ∈ k • A), k • A)
⊢ ∀ (i : M), a ∈ ⋂ (_ : a ∈ i • A), i • A
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | Rudio | [754, 1] | [777, 17] | simp only [Set.mem_iInter, imp_self] | case inl
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : Set.Subsingleton (⋂ k, ⋂ (_ : a ∈ k • A), k • A)
g : M
⊢ a ∈ ⋂ (_ : a ∈ g • A), g • A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : Set.Subsingleton (⋂ k, ⋂ (_ : a ∈ k • A), k • A)
g : M
⊢ a ∈ ⋂ (_ : a ∈ g • A), g • A
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | Rudio | [754, 1] | [777, 17] | change B = ⊤ at hyp | case inr
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : ⋂ k, ⋂ (_ : a ∈ k • A), k • A = ⊤
⊢ B = {a} | case inr
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
⊢ B = {a} | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : ⋂ k, ⋂ (_ : a ∈ k • A), k • A = ⊤
⊢ B = {a}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | Rudio | [754, 1] | [777, 17] | exfalso | case inr
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
⊢ B = {a} | case inr
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
⊢ B = {a}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | Rudio | [754, 1] | [777, 17] | apply hA' | case inr
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
⊢ False | case inr
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
⊢ A = ⊤ | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | Rudio | [754, 1] | [777, 17] | suffices ∃ g : M, a ∈ g • A by
obtain ⟨g, hg⟩ := this
have : B ≤ g • A := Set.biInter_subset_of_mem hg
rw [hyp, top_le_iff, ← eq_inv_smul_iff] at this
rw [this, Set.top_eq_univ, Set.smul_set_univ] | case inr
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
⊢ A = ⊤ | case inr
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
⊢ ∃ g, a ∈ g • A | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
⊢ A = ⊤
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | Rudio | [754, 1] | [777, 17] | obtain ⟨x, hx⟩ := hA | case inr
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
⊢ ∃ g, a ∈ g • A | case inr.intro
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
x : α
hx : x ∈ A
⊢ ∃ g, a ∈ g • A | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
⊢ ∃ g, a ∈ g • A
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | Rudio | [754, 1] | [777, 17] | obtain ⟨g, hg⟩ := MulAction.exists_smul_eq M x a | case inr.intro
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
x : α
hx : x ∈ A
⊢ ∃ g, a ∈ g • A | case inr.intro.intro
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
x : α
hx : x ∈ A
g : M
hg : g • x = a
⊢ ∃ g, a ∈ g • A | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
x : α
hx : x ∈ A
⊢ ∃ g, a ∈ g • A
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | Rudio | [754, 1] | [777, 17] | use g | case inr.intro.intro
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
x : α
hx : x ∈ A
g : M
hg : g • x = a
⊢ ∃ g, a ∈ g • A | case h
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
x : α
hx : x ∈ A
g : M
hg : g • x = a
⊢ a ∈ g • A | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
x : α
hx : x ∈ A
g : M
hg : g • x = a
⊢ ∃ g, a ∈ g • A
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | Rudio | [754, 1] | [777, 17] | use x | case h
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
x : α
hx : x ∈ A
g : M
hg : g • x = a
⊢ a ∈ g • A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
x : α
hx : x ∈ A
g : M
hg : g • x = a
⊢ a ∈ g • A
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | Rudio | [754, 1] | [777, 17] | obtain ⟨g, hg⟩ := this | M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
this : ∃ g, a ∈ g • A
⊢ A = ⊤ | case intro
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
g : M
hg : a ∈ g • A
⊢ A = ⊤ | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
this : ∃ g, a ∈ g • A
⊢ A = ⊤
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | Rudio | [754, 1] | [777, 17] | have : B ≤ g • A := Set.biInter_subset_of_mem hg | case intro
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
g : M
hg : a ∈ g • A
⊢ A = ⊤ | case intro
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
g : M
hg : a ∈ g • A
this : B ≤ g • A
⊢ A = ⊤ | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
g : M
hg : a ∈ g • A
⊢ A = ⊤
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | Rudio | [754, 1] | [777, 17] | rw [hyp, top_le_iff, ← eq_inv_smul_iff] at this | case intro
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
g : M
hg : a ∈ g • A
this : B ≤ g • A
⊢ A = ⊤ | case intro
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
g : M
hg : a ∈ g • A
this : A = g⁻¹ • ⊤
⊢ A = ⊤ | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
g : M
hg : a ∈ g • A
this : B ≤ g • A
⊢ A = ⊤
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Primitive.lean | Rudio | [754, 1] | [777, 17] | rw [this, Set.top_eq_univ, Set.smul_set_univ] | case intro
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
g : M
hg : a ∈ g • A
this : A = g⁻¹ • ⊤
⊢ A = ⊤ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
M : Type u_1
inst✝³ : Group M
α : Type u_2
inst✝² : MulAction M α
N : Type ?u.94224
β : Type ?u.94227
inst✝¹ : Group N
inst✝ : MulAction N β
hpGX : IsPreprimitive M α
A : Set α
hfA : Set.Finite A
hA : Set.Nonempty A
hA' : A ≠ ⊤
a b : α
h : a ≠ b
B : Set α := ⋂ g, ⋂ (_ : a ∈ g • A), g • A
hyp : B = ⊤
g : M
hg : a ∈ g • A
this : A = g⁻¹ • ⊤
⊢ A = ⊤
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | Nat.add_lt_of_le_lt | [45, 1] | [49, 35] | apply Nat.lt_of_lt_of_le | a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ a + b < c + d | case a
a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ a + b < ?m
case a
a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ ?m ≤ c + d
case m
a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ ℕ | Please generate a tactic in lean4 to solve the state.
STATE:
a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ a + b < c + d
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | Nat.add_lt_of_le_lt | [45, 1] | [49, 35] | apply Nat.add_lt_add_left _ a | case a
a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ a + b < ?m
case a
a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ ?m ≤ c + d
case m
a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ ℕ | a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ ℕ
a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ b < ?m.126
case a
a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ a + ?m.126 ≤ c + d | Please generate a tactic in lean4 to solve the state.
STATE:
case a
a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ a + b < ?m
case a
a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ ?m ≤ c + d
case m
a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ ℕ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | Nat.add_lt_of_le_lt | [45, 1] | [49, 35] | use d | a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ ℕ
a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ b < ?m.126
case a
a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ a + ?m.126 ≤ c + d | a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ b < d
case a
a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ a + d ≤ c + d | Please generate a tactic in lean4 to solve the state.
STATE:
a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ ℕ
a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ b < ?m.126
case a
a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ a + ?m.126 ≤ c + d
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | Nat.add_lt_of_le_lt | [45, 1] | [49, 35] | exact hbd | a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ b < d
case a
a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ a + d ≤ c + d | case a
a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ a + d ≤ c + d | Please generate a tactic in lean4 to solve the state.
STATE:
a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ b < d
case a
a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ a + d ≤ c + d
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | Nat.add_lt_of_le_lt | [45, 1] | [49, 35] | apply Nat.add_le_add_right hab d | case a
a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ a + d ≤ c + d | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
a b c d : ℕ
hab : a ≤ c
hbd : b < d
⊢ a + d ≤ c + d
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | subgroup_of_group_of_order_two | [52, 1] | [68, 23] | apply Or.intro_left | case inl
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : Fintype.card ↥H ≤ 1
⊢ H = ⊥ ∨ H = ⊤ | case inl.h
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : Fintype.card ↥H ≤ 1
⊢ H = ⊥ | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : Fintype.card ↥H ≤ 1
⊢ H = ⊥ ∨ H = ⊤
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | subgroup_of_group_of_order_two | [52, 1] | [68, 23] | apply Subgroup.eq_bot_of_card_le | case inl.h
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : Fintype.card ↥H ≤ 1
⊢ H = ⊥ | case inl.h.h
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : Fintype.card ↥H ≤ 1
⊢ Fintype.card ↥H ≤ 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.h
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : Fintype.card ↥H ≤ 1
⊢ H = ⊥
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | subgroup_of_group_of_order_two | [52, 1] | [68, 23] | exact h | case inl.h.h
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : Fintype.card ↥H ≤ 1
⊢ Fintype.card ↥H ≤ 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.h.h
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : Fintype.card ↥H ≤ 1
⊢ Fintype.card ↥H ≤ 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | subgroup_of_group_of_order_two | [52, 1] | [68, 23] | apply Or.intro_right | case inr
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ H = ⊥ ∨ H = ⊤ | case inr.h
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ H = ⊤ | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ H = ⊥ ∨ H = ⊤
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | subgroup_of_group_of_order_two | [52, 1] | [68, 23] | apply Subgroup.eq_top_of_card_eq | case inr.h
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ H = ⊤ | case inr.h.h
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ Fintype.card ↥H = Fintype.card G | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.h
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ H = ⊤
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | subgroup_of_group_of_order_two | [52, 1] | [68, 23] | apply le_antisymm | case inr.h.h
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ Fintype.card ↥H = Fintype.card G | case inr.h.h.a
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ Fintype.card ↥H ≤ Fintype.card G
case inr.h.h.a
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ Fintype.card G ≤ Fintype.card ↥H | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.h.h
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ Fintype.card ↥H = Fintype.card G
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | subgroup_of_group_of_order_two | [52, 1] | [68, 23] | apply Nat.le_of_dvd | case inr.h.h.a
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ Fintype.card ↥H ≤ Fintype.card G | case inr.h.h.a.h
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ 0 < Fintype.card G
case inr.h.h.a.a
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ Fintype.card ↥H ∣ Fintype.card G | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.h.h.a
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ Fintype.card ↥H ≤ Fintype.card G
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | subgroup_of_group_of_order_two | [52, 1] | [68, 23] | refine' Fintype.card_pos | case inr.h.h.a.h
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ 0 < Fintype.card G
case inr.h.h.a.a
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ Fintype.card ↥H ∣ Fintype.card G | case inr.h.h.a.a
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ Fintype.card ↥H ∣ Fintype.card G | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.h.h.a.h
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ 0 < Fintype.card G
case inr.h.h.a.a
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ Fintype.card ↥H ∣ Fintype.card G
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | subgroup_of_group_of_order_two | [52, 1] | [68, 23] | refine' Subgroup.card_subgroup_dvd_card H | case inr.h.h.a.a
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ Fintype.card ↥H ∣ Fintype.card G | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.h.h.a.a
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ Fintype.card ↥H ∣ Fintype.card G
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | subgroup_of_group_of_order_two | [52, 1] | [68, 23] | rw [hG] | case inr.h.h.a
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ Fintype.card G ≤ Fintype.card ↥H | case inr.h.h.a
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ 2 ≤ Fintype.card ↥H | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.h.h.a
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ Fintype.card G ≤ Fintype.card ↥H
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | subgroup_of_group_of_order_two | [52, 1] | [68, 23] | exact h | case inr.h.h.a
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ 2 ≤ Fintype.card ↥H | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.h.h.a
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
hG : Fintype.card G = 2
H : Subgroup G
h : 1 < Fintype.card ↥H
⊢ 2 ≤ Fintype.card ↥H
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | Equiv.Perm.IsPretransitive.of_partition | [77, 1] | [102, 45] | intro hs hs' hG | α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
⊢ (∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b) → (∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b) → stabilizer G s ≠ ⊤ → IsPretransitive G α | α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
⊢ IsPretransitive G α | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
⊢ (∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b) → (∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b) → stabilizer G s ≠ ⊤ → IsPretransitive G α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | Equiv.Perm.IsPretransitive.of_partition | [77, 1] | [102, 45] | by_contra hyp | α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
⊢ ∃ a b g, a ∈ s ∧ b ∈ sᶜ ∧ g • a = b | α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
hyp : ¬∃ a b g, a ∈ s ∧ b ∈ sᶜ ∧ g • a = b
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
⊢ ∃ a b g, a ∈ s ∧ b ∈ sᶜ ∧ g • a = b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | Equiv.Perm.IsPretransitive.of_partition | [77, 1] | [102, 45] | push_neg at hyp | α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
hyp : ¬∃ a b g, a ∈ s ∧ b ∈ sᶜ ∧ g • a = b
⊢ False | α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
hyp : ∀ (a b : α) (g : G), a ∈ s → b ∈ sᶜ → g • a ≠ b
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
hyp : ¬∃ a b g, a ∈ s ∧ b ∈ sᶜ ∧ g • a = b
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | Equiv.Perm.IsPretransitive.of_partition | [77, 1] | [102, 45] | apply hG | α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
hyp : ∀ (a b : α) (g : G), a ∈ s → b ∈ sᶜ → g • a ≠ b
⊢ False | α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
hyp : ∀ (a b : α) (g : G), a ∈ s → b ∈ sᶜ → g • a ≠ b
⊢ stabilizer G s = ⊤ | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
hyp : ∀ (a b : α) (g : G), a ∈ s → b ∈ sᶜ → g • a ≠ b
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | Equiv.Perm.IsPretransitive.of_partition | [77, 1] | [102, 45] | rw [eq_top_iff, MulAction.le_stabilizer_iff_smul_le] | α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
hyp : ∀ (a b : α) (g : G), a ∈ s → b ∈ sᶜ → g • a ≠ b
⊢ stabilizer G s = ⊤ | α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
hyp : ∀ (a b : α) (g : G), a ∈ s → b ∈ sᶜ → g • a ≠ b
⊢ ∀ g ∈ ⊤, g • s ⊆ s | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
hyp : ∀ (a b : α) (g : G), a ∈ s → b ∈ sᶜ → g • a ≠ b
⊢ stabilizer G s = ⊤
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | Equiv.Perm.IsPretransitive.of_partition | [77, 1] | [102, 45] | intro g _ | α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
hyp : ∀ (a b : α) (g : G), a ∈ s → b ∈ sᶜ → g • a ≠ b
⊢ ∀ g ∈ ⊤, g • s ⊆ s | α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
hyp : ∀ (a b : α) (g : G), a ∈ s → b ∈ sᶜ → g • a ≠ b
g : G
a✝ : g ∈ ⊤
⊢ g • s ⊆ s | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
hyp : ∀ (a b : α) (g : G), a ∈ s → b ∈ sᶜ → g • a ≠ b
⊢ ∀ g ∈ ⊤, g • s ⊆ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | Equiv.Perm.IsPretransitive.of_partition | [77, 1] | [102, 45] | rintro b ⟨a, ha, hgab⟩ | α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
hyp : ∀ (a b : α) (g : G), a ∈ s → b ∈ sᶜ → g • a ≠ b
g : G
a✝ : g ∈ ⊤
⊢ g • s ⊆ s | case intro.intro
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
hyp : ∀ (a b : α) (g : G), a ∈ s → b ∈ sᶜ → g • a ≠ b
g : G
a✝ : g ∈ ⊤
b a : α
ha : a ∈ s
hgab : (fun x => g • x) a = b
⊢ b ∈ s | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
hyp : ∀ (a b : α) (g : G), a ∈ s → b ∈ sᶜ → g • a ≠ b
g : G
a✝ : g ∈ ⊤
⊢ g • s ⊆ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | Equiv.Perm.IsPretransitive.of_partition | [77, 1] | [102, 45] | by_contra hb | case intro.intro
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
hyp : ∀ (a b : α) (g : G), a ∈ s → b ∈ sᶜ → g • a ≠ b
g : G
a✝ : g ∈ ⊤
b a : α
ha : a ∈ s
hgab : (fun x => g • x) a = b
⊢ b ∈ s | case intro.intro
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
hyp : ∀ (a b : α) (g : G), a ∈ s → b ∈ sᶜ → g • a ≠ b
g : G
a✝ : g ∈ ⊤
b a : α
ha : a ∈ s
hgab : (fun x => g • x) a = b
hb : b ∉ s
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
hyp : ∀ (a b : α) (g : G), a ∈ s → b ∈ sᶜ → g • a ≠ b
g : G
a✝ : g ∈ ⊤
b a : α
ha : a ∈ s
hgab : (fun x => g • x) a = b
⊢ b ∈ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | Equiv.Perm.IsPretransitive.of_partition | [77, 1] | [102, 45] | exact hyp a b g ha (Set.mem_compl hb) hgab | case intro.intro
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
hyp : ∀ (a b : α) (g : G), a ∈ s → b ∈ sᶜ → g • a ≠ b
g : G
a✝ : g ∈ ⊤
b a : α
ha : a ∈ s
hgab : (fun x => g • x) a = b
hb : b ∉ s
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
hyp : ∀ (a b : α) (g : G), a ∈ s → b ∈ sᶜ → g • a ≠ b
g : G
a✝ : g ∈ ⊤
b a : α
ha : a ∈ s
hgab : (fun x => g • x) a = b
hb : b ∉ s
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | Equiv.Perm.IsPretransitive.of_partition | [77, 1] | [102, 45] | obtain ⟨a, b, g, ha, hb, hgab⟩ := hss' | α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
hss' : ∃ a b g, a ∈ s ∧ b ∈ sᶜ ∧ g • a = b
⊢ IsPretransitive G α | case intro.intro.intro.intro.intro
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
a b : α
g : G
ha : a ∈ s
hb : b ∈ sᶜ
hgab : g • a = b
⊢ IsPretransitive G α | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
hss' : ∃ a b g, a ∈ s ∧ b ∈ sᶜ ∧ g • a = b
⊢ IsPretransitive G α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | Equiv.Perm.IsPretransitive.of_partition | [77, 1] | [102, 45] | apply IsPretransitive.mk_base a | case intro.intro.intro.intro.intro
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
a b : α
g : G
ha : a ∈ s
hb : b ∈ sᶜ
hgab : g • a = b
⊢ IsPretransitive G α | case intro.intro.intro.intro.intro
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
a b : α
g : G
ha : a ∈ s
hb : b ∈ sᶜ
hgab : g • a = b
⊢ ∀ (x : α), ∃ g, g • a = x | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro.intro
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
a b : α
g : G
ha : a ∈ s
hb : b ∈ sᶜ
hgab : g • a = b
⊢ IsPretransitive G α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | Equiv.Perm.IsPretransitive.of_partition | [77, 1] | [102, 45] | intro x | case intro.intro.intro.intro.intro
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
a b : α
g : G
ha : a ∈ s
hb : b ∈ sᶜ
hgab : g • a = b
⊢ ∀ (x : α), ∃ g, g • a = x | case intro.intro.intro.intro.intro
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
a b : α
g : G
ha : a ∈ s
hb : b ∈ sᶜ
hgab : g • a = b
x : α
⊢ ∃ g, g • a = x | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro.intro
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
a b : α
g : G
ha : a ∈ s
hb : b ∈ sᶜ
hgab : g • a = b
⊢ ∀ (x : α), ∃ g, g • a = x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | Equiv.Perm.IsPretransitive.of_partition | [77, 1] | [102, 45] | by_cases hx : x ∈ s | case intro.intro.intro.intro.intro
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
a b : α
g : G
ha : a ∈ s
hb : b ∈ sᶜ
hgab : g • a = b
x : α
⊢ ∃ g, g • a = x | case pos
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
a b : α
g : G
ha : a ∈ s
hb : b ∈ sᶜ
hgab : g • a = b
x : α
hx : x ∈ s
⊢ ∃ g, g • a = x
case neg
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
a b : α
g : G
ha : a ∈ s
hb : b ∈ sᶜ
hgab : g • a = b
x : α
hx : x ∉ s
⊢ ∃ g, g • a = x | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro.intro
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
a b : α
g : G
ha : a ∈ s
hb : b ∈ sᶜ
hgab : g • a = b
x : α
⊢ ∃ g, g • a = x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | Equiv.Perm.IsPretransitive.of_partition | [77, 1] | [102, 45] | exact hs a ha x hx | case pos
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
a b : α
g : G
ha : a ∈ s
hb : b ∈ sᶜ
hgab : g • a = b
x : α
hx : x ∈ s
⊢ ∃ g, g • a = x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
a b : α
g : G
ha : a ∈ s
hb : b ∈ sᶜ
hgab : g • a = b
x : α
hx : x ∈ s
⊢ ∃ g, g • a = x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | Equiv.Perm.IsPretransitive.of_partition | [77, 1] | [102, 45] | rw [← Set.mem_compl_iff] at hx | case neg
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
a b : α
g : G
ha : a ∈ s
hb : b ∈ sᶜ
hgab : g • a = b
x : α
hx : x ∉ s
⊢ ∃ g, g • a = x | case neg
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
a b : α
g : G
ha : a ∈ s
hb : b ∈ sᶜ
hgab : g • a = b
x : α
hx : x ∈ sᶜ
⊢ ∃ g, g • a = x | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
a b : α
g : G
ha : a ∈ s
hb : b ∈ sᶜ
hgab : g • a = b
x : α
hx : x ∉ s
⊢ ∃ g, g • a = x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | Equiv.Perm.IsPretransitive.of_partition | [77, 1] | [102, 45] | obtain ⟨k, hk⟩ := hs' b hb x hx | case neg
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
a b : α
g : G
ha : a ∈ s
hb : b ∈ sᶜ
hgab : g • a = b
x : α
hx : x ∈ sᶜ
⊢ ∃ g, g • a = x | case neg.intro
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
a b : α
g : G
ha : a ∈ s
hb : b ∈ sᶜ
hgab : g • a = b
x : α
hx : x ∈ sᶜ
k : G
hk : k • b = x
⊢ ∃ g, g • a = x | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
a b : α
g : G
ha : a ∈ s
hb : b ∈ sᶜ
hgab : g • a = b
x : α
hx : x ∈ sᶜ
⊢ ∃ g, g • a = x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/PermMaximal.lean | Equiv.Perm.IsPretransitive.of_partition | [77, 1] | [102, 45] | use k * g | case neg.intro
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
a b : α
g : G
ha : a ∈ s
hb : b ∈ sᶜ
hgab : g • a = b
x : α
hx : x ∈ sᶜ
k : G
hk : k • b = x
⊢ ∃ g, g • a = x | case h
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
a b : α
g : G
ha : a ∈ s
hb : b ∈ sᶜ
hgab : g • a = b
x : α
hx : x ∈ sᶜ
k : G
hk : k • b = x
⊢ (k * g) • a = x | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.intro
α : Type u_1
inst✝² : DecidableEq α
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G α
s : Set α
hs : ∀ a ∈ s, ∀ b ∈ s, ∃ g, g • a = b
hs' : ∀ a ∈ sᶜ, ∀ b ∈ sᶜ, ∃ g, g • a = b
hG : stabilizer G s ≠ ⊤
a b : α
g : G
ha : a ∈ s
hb : b ∈ sᶜ
hgab : g • a = b
x : α
hx : x ∈ sᶜ
k : G
hk : k • b = x
⊢ ∃ g, g • a = x
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.