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/Blocks.lean | MulAction.is_top_of_large_block | [720, 1] | [745, 41] | cases' Set.eq_empty_or_nonempty B with hB_e hB_ne | G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard B
this : Fintype X := Fintype.ofFinite X
⊢ B = ⊤ | case inl
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard B
this : Fintype X := Fintype.ofFinite X
hB_e : B = ∅
⊢ B = ⊤
case inr
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
⊢ B = ⊤ | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard B
this : Fintype X := Fintype.ofFinite X
⊢ B = ⊤
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.is_top_of_large_block | [720, 1] | [745, 41] | rw [Set.top_eq_univ, ← Set.toFinset_inj, Set.toFinset_univ, ← Finset.card_eq_iff_eq_univ, ← Set.ncard_eq_toFinset_card'] | case inr
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
⊢ B = ⊤ | case inr
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
⊢ Set.ncard B = Fintype.card X | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
⊢ B = ⊤
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.is_top_of_large_block | [720, 1] | [745, 41] | obtain ⟨k, h⟩ := ncard_of_block_divides hB hB_ne | case inr
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
⊢ Set.ncard B = Fintype.card X | case inr.intro
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
h : Nat.card X = Set.ncard B * k
⊢ Set.ncard B = Fintype.card X | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
⊢ Set.ncard B = Fintype.card X
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.is_top_of_large_block | [720, 1] | [745, 41] | simp only [← Nat.card_eq_fintype_card] | case inr.intro
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
h : Nat.card X = Set.ncard B * k
⊢ Set.ncard B = Fintype.card X | case inr.intro
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
h : Nat.card X = Set.ncard B * k
⊢ Set.ncard B = Nat.card X | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
h : Nat.card X = Set.ncard B * k
⊢ Set.ncard B = Fintype.card X
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.is_top_of_large_block | [720, 1] | [745, 41] | rw [h] at hB' ⊢ | case inr.intro
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
h : Nat.card X = Set.ncard B * k
⊢ Set.ncard B = Nat.card X | case inr.intro
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
⊢ Set.ncard B = Set.ncard B * k | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
h : Nat.card X = Set.ncard B * k
⊢ Set.ncard B = Nat.card X
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.is_top_of_large_block | [720, 1] | [745, 41] | suffices k = 1 by
simp only [this, mul_one] | case inr.intro
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
⊢ Set.ncard B = Set.ncard B * k | case inr.intro
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
⊢ k = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
⊢ Set.ncard B = Set.ncard B * k
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.is_top_of_large_block | [720, 1] | [745, 41] | apply le_antisymm | case inr.intro
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
⊢ k = 1 | case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
⊢ k ≤ 1
case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
⊢ 1 ≤ k | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
⊢ k = 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.is_top_of_large_block | [720, 1] | [745, 41] | exfalso | case inl
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard B
this : Fintype X := Fintype.ofFinite X
hB_e : B = ∅
⊢ B = ⊤ | case inl
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard B
this : Fintype X := Fintype.ofFinite X
hB_e : B = ∅
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard B
this : Fintype X := Fintype.ofFinite X
hB_e : B = ∅
⊢ B = ⊤
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.is_top_of_large_block | [720, 1] | [745, 41] | rw [hB_e] at hB' | case inl
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard B
this : Fintype X := Fintype.ofFinite X
hB_e : B = ∅
⊢ False | case inl
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard ∅
this : Fintype X := Fintype.ofFinite X
hB_e : B = ∅
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard B
this : Fintype X := Fintype.ofFinite X
hB_e : B = ∅
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.is_top_of_large_block | [720, 1] | [745, 41] | simp only [Set.ncard_empty, mul_zero, gt_iff_lt, not_lt_zero'] at hB' | case inl
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard ∅
this : Fintype X := Fintype.ofFinite X
hB_e : B = ∅
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard ∅
this : Fintype X := Fintype.ofFinite X
hB_e : B = ∅
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.is_top_of_large_block | [720, 1] | [745, 41] | simp only [this, mul_one] | G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this✝ : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
this : k = 1
⊢ Set.ncard B = Set.ncard B * k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this✝ : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
this : k = 1
⊢ Set.ncard B = Set.ncard B * k
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.is_top_of_large_block | [720, 1] | [745, 41] | rw [← not_lt, ← Nat.succ_le_iff] | case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
⊢ k ≤ 1 | case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
⊢ ¬Nat.succ 1 ≤ k | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
⊢ k ≤ 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.is_top_of_large_block | [720, 1] | [745, 41] | intro hk | case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
⊢ ¬Nat.succ 1 ≤ k | case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
hk : Nat.succ 1 ≤ k
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
⊢ ¬Nat.succ 1 ≤ k
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.is_top_of_large_block | [720, 1] | [745, 41] | rw [← not_le] at hB' | case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
hk : Nat.succ 1 ≤ k
⊢ False | case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : ¬2 * Set.ncard B ≤ Set.ncard B * k
h : Nat.card X = Set.ncard B * k
hk : Nat.succ 1 ≤ k
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
hk : Nat.succ 1 ≤ k
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.is_top_of_large_block | [720, 1] | [745, 41] | apply hB' | case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : ¬2 * Set.ncard B ≤ Set.ncard B * k
h : Nat.card X = Set.ncard B * k
hk : Nat.succ 1 ≤ k
⊢ False | case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : ¬2 * Set.ncard B ≤ Set.ncard B * k
h : Nat.card X = Set.ncard B * k
hk : Nat.succ 1 ≤ k
⊢ 2 * Set.ncard B ≤ Set.ncard B * k | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : ¬2 * Set.ncard B ≤ Set.ncard B * k
h : Nat.card X = Set.ncard B * k
hk : Nat.succ 1 ≤ k
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.is_top_of_large_block | [720, 1] | [745, 41] | rw [mul_comm] | case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : ¬2 * Set.ncard B ≤ Set.ncard B * k
h : Nat.card X = Set.ncard B * k
hk : Nat.succ 1 ≤ k
⊢ 2 * Set.ncard B ≤ Set.ncard B * k | case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : ¬2 * Set.ncard B ≤ Set.ncard B * k
h : Nat.card X = Set.ncard B * k
hk : Nat.succ 1 ≤ k
⊢ Set.ncard B * 2 ≤ Set.ncard B * k | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : ¬2 * Set.ncard B ≤ Set.ncard B * k
h : Nat.card X = Set.ncard B * k
hk : Nat.succ 1 ≤ k
⊢ 2 * Set.ncard B ≤ Set.ncard B * k
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.is_top_of_large_block | [720, 1] | [745, 41] | apply Nat.mul_le_mul_left _ hk | case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : ¬2 * Set.ncard B ≤ Set.ncard B * k
h : Nat.card X = Set.ncard B * k
hk : Nat.succ 1 ≤ k
⊢ Set.ncard B * 2 ≤ Set.ncard B * k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : ¬2 * Set.ncard B ≤ Set.ncard B * k
h : Nat.card X = Set.ncard B * k
hk : Nat.succ 1 ≤ k
⊢ Set.ncard B * 2 ≤ Set.ncard B * k
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.is_top_of_large_block | [720, 1] | [745, 41] | rw [← not_lt, Nat.lt_one_iff] | case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
⊢ 1 ≤ k | case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
⊢ ¬k = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
⊢ 1 ≤ k
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.is_top_of_large_block | [720, 1] | [745, 41] | intro hk | case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
⊢ ¬k = 0 | case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
hk : k = 0
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
⊢ ¬k = 0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.is_top_of_large_block | [720, 1] | [745, 41] | simp only [Nat.card_eq_fintype_card, hk, mul_zero, Fintype.card_eq_zero_iff, ← not_nonempty_iff] at h | case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
hk : k = 0
⊢ False | case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
hk : k = 0
h : ¬Nonempty X
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
h : Nat.card X = Set.ncard B * k
hk : k = 0
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.is_top_of_large_block | [720, 1] | [745, 41] | exact h (Set.Nonempty.to_type hB_ne) | case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
hk : k = 0
h : ¬Nonempty X
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.a
G : Type u_2
inst✝¹ : Group G
X : Type u_1
inst✝ : MulAction G X
hfX : Finite X
hGX : IsPretransitive G X
B : Set X
hB : IsBlock G B
this : Fintype X := Fintype.ofFinite X
hB_ne : Set.Nonempty B
k : ℕ
hB' : Set.ncard B * k < 2 * Set.ncard B
hk : k = 0
h : ¬Nonempty X
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.is_subsingleton | [749, 1] | [769, 40] | have := Fintype.ofFinite X | G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
⊢ Set.Subsingleton B | G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
⊢ Set.Subsingleton B | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
⊢ Set.Subsingleton B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.is_subsingleton | [749, 1] | [769, 40] | suffices Set.ncard B ≤ 1 by
rw [Set.ncard_le_one_iff_eq] at this
cases' this with h h
rw [h]; exact Set.subsingleton_empty
obtain ⟨a, ha⟩ := h; rw [ha]; exact Set.subsingleton_singleton | G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
⊢ Set.Subsingleton B | G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
⊢ Set.ncard B ≤ 1 | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
⊢ Set.Subsingleton B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.is_subsingleton | [749, 1] | [769, 40] | rw [Set.ncard_le_one_iff_eq] at this | G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this✝ : Fintype X
this : Set.ncard B ≤ 1
⊢ Set.Subsingleton B | G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this✝ : Fintype X
this : B = ∅ ∨ ∃ a, B = {a}
⊢ Set.Subsingleton B | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this✝ : Fintype X
this : Set.ncard B ≤ 1
⊢ Set.Subsingleton B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.is_subsingleton | [749, 1] | [769, 40] | cases' this with h h | G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this✝ : Fintype X
this : B = ∅ ∨ ∃ a, B = {a}
⊢ Set.Subsingleton B | case inl
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : B = ∅
⊢ Set.Subsingleton B
case inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : ∃ a, B = {a}
⊢ Set.Subsingleton B | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this✝ : Fintype X
this : B = ∅ ∨ ∃ a, B = {a}
⊢ Set.Subsingleton B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.is_subsingleton | [749, 1] | [769, 40] | rw [h] | case inl
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : B = ∅
⊢ Set.Subsingleton B
case inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : ∃ a, B = {a}
⊢ Set.Subsingleton B | case inl
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : B = ∅
⊢ Set.Subsingleton ∅
case inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : ∃ a, B = {a}
⊢ Set.Subsingleton B | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : B = ∅
⊢ Set.Subsingleton B
case inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : ∃ a, B = {a}
⊢ Set.Subsingleton B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.is_subsingleton | [749, 1] | [769, 40] | exact Set.subsingleton_empty | case inl
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : B = ∅
⊢ Set.Subsingleton ∅
case inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : ∃ a, B = {a}
⊢ Set.Subsingleton B | case inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : ∃ a, B = {a}
⊢ Set.Subsingleton B | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : B = ∅
⊢ Set.Subsingleton ∅
case inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : ∃ a, B = {a}
⊢ Set.Subsingleton B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.is_subsingleton | [749, 1] | [769, 40] | obtain ⟨a, ha⟩ := h | case inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : ∃ a, B = {a}
⊢ Set.Subsingleton B | case inr.intro
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
a : X
ha : B = {a}
⊢ Set.Subsingleton B | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : ∃ a, B = {a}
⊢ Set.Subsingleton B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.is_subsingleton | [749, 1] | [769, 40] | rw [ha] | case inr.intro
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
a : X
ha : B = {a}
⊢ Set.Subsingleton B | case inr.intro
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
a : X
ha : B = {a}
⊢ Set.Subsingleton {a} | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
a : X
ha : B = {a}
⊢ Set.Subsingleton B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.is_subsingleton | [749, 1] | [769, 40] | exact Set.subsingleton_singleton | case inr.intro
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
a : X
ha : B = {a}
⊢ Set.Subsingleton {a} | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
a : X
ha : B = {a}
⊢ Set.Subsingleton {a}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.is_subsingleton | [749, 1] | [769, 40] | rw [h, Set.ncard_empty] | case inl
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : B = ∅
⊢ Set.ncard B ≤ 1 | case inl
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : B = ∅
⊢ 0 ≤ 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : B = ∅
⊢ Set.ncard B ≤ 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.is_subsingleton | [749, 1] | [769, 40] | norm_num | case inl
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : B = ∅
⊢ 0 ≤ 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : B = ∅
⊢ 0 ≤ 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.is_subsingleton | [749, 1] | [769, 40] | let hk := ncard_block_mul_ncard_orbit_eq hB h | case inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : Set.Nonempty B
⊢ Set.ncard B ≤ 1 | case inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : Set.Nonempty B
hk : Set.ncard B * Set.ncard (Set.range fun g => g • B) = Nat.card X := ncard_block_mul_ncard_orbit_eq hB h
⊢ Set.ncard B ≤ 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : Set.Nonempty B
⊢ Set.ncard B ≤ 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.is_subsingleton | [749, 1] | [769, 40] | cases' Nat.lt_or_ge (Set.ncard B) 2 with hb hb | case inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : Set.Nonempty B
hk : Set.ncard B * Set.ncard (Set.range fun g => g • B) = Nat.card X := ncard_block_mul_ncard_orbit_eq hB h
⊢ Set.ncard B ≤ 1 | case inr.inl
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : Set.Nonempty B
hk : Set.ncard B * Set.ncard (Set.range fun g => g • B) = Nat.card X := ncard_block_mul_ncard_orbit_eq hB h
hb : Set.ncard B < 2
⊢ Set.ncard B ≤ 1
case inr.inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : Set.Nonempty B
hk : Set.ncard B * Set.ncard (Set.range fun g => g • B) = Nat.card X := ncard_block_mul_ncard_orbit_eq hB h
hb : Set.ncard B ≥ 2
⊢ Set.ncard B ≤ 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : Set.Nonempty B
hk : Set.ncard B * Set.ncard (Set.range fun g => g • B) = Nat.card X := ncard_block_mul_ncard_orbit_eq hB h
⊢ Set.ncard B ≤ 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.is_subsingleton | [749, 1] | [769, 40] | rw [← Nat.lt_succ_iff] | case inr.inl
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : Set.Nonempty B
hk : Set.ncard B * Set.ncard (Set.range fun g => g • B) = Nat.card X := ncard_block_mul_ncard_orbit_eq hB h
hb : Set.ncard B < 2
⊢ Set.ncard B ≤ 1 | case inr.inl
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : Set.Nonempty B
hk : Set.ncard B * Set.ncard (Set.range fun g => g • B) = Nat.card X := ncard_block_mul_ncard_orbit_eq hB h
hb : Set.ncard B < 2
⊢ Set.ncard B < Nat.succ 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : Set.Nonempty B
hk : Set.ncard B * Set.ncard (Set.range fun g => g • B) = Nat.card X := ncard_block_mul_ncard_orbit_eq hB h
hb : Set.ncard B < 2
⊢ Set.ncard B ≤ 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.is_subsingleton | [749, 1] | [769, 40] | exact hb | case inr.inl
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : Set.Nonempty B
hk : Set.ncard B * Set.ncard (Set.range fun g => g • B) = Nat.card X := ncard_block_mul_ncard_orbit_eq hB h
hb : Set.ncard B < 2
⊢ Set.ncard B < Nat.succ 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : Set.Nonempty B
hk : Set.ncard B * Set.ncard (Set.range fun g => g • B) = Nat.card X := ncard_block_mul_ncard_orbit_eq hB h
hb : Set.ncard B < 2
⊢ Set.ncard B < Nat.succ 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.is_subsingleton | [749, 1] | [769, 40] | exfalso | case inr.inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : Set.Nonempty B
hk : Set.ncard B * Set.ncard (Set.range fun g => g • B) = Nat.card X := ncard_block_mul_ncard_orbit_eq hB h
hb : Set.ncard B ≥ 2
⊢ Set.ncard B ≤ 1 | case inr.inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : Set.Nonempty B
hk : Set.ncard B * Set.ncard (Set.range fun g => g • B) = Nat.card X := ncard_block_mul_ncard_orbit_eq hB h
hb : Set.ncard B ≥ 2
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : Set.Nonempty B
hk : Set.ncard B * Set.ncard (Set.range fun g => g • B) = Nat.card X := ncard_block_mul_ncard_orbit_eq hB h
hb : Set.ncard B ≥ 2
⊢ Set.ncard B ≤ 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.is_subsingleton | [749, 1] | [769, 40] | rw [← hk, lt_iff_not_ge] at hB' | case inr.inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : Set.Nonempty B
hk : Set.ncard B * Set.ncard (Set.range fun g => g • B) = Nat.card X := ncard_block_mul_ncard_orbit_eq hB h
hb : Set.ncard B ≥ 2
⊢ False | case inr.inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : ¬Set.ncard B * Set.ncard (Set.range fun g => g • B) ≥ 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : Set.Nonempty B
hk : Set.ncard B * Set.ncard (Set.range fun g => g • B) = Nat.card X := ncard_block_mul_ncard_orbit_eq hB h
hb : Set.ncard B ≥ 2
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : Nat.card X < 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : Set.Nonempty B
hk : Set.ncard B * Set.ncard (Set.range fun g => g • B) = Nat.card X := ncard_block_mul_ncard_orbit_eq hB h
hb : Set.ncard B ≥ 2
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.is_subsingleton | [749, 1] | [769, 40] | apply hB' | case inr.inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : ¬Set.ncard B * Set.ncard (Set.range fun g => g • B) ≥ 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : Set.Nonempty B
hk : Set.ncard B * Set.ncard (Set.range fun g => g • B) = Nat.card X := ncard_block_mul_ncard_orbit_eq hB h
hb : Set.ncard B ≥ 2
⊢ False | case inr.inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : ¬Set.ncard B * Set.ncard (Set.range fun g => g • B) ≥ 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : Set.Nonempty B
hk : Set.ncard B * Set.ncard (Set.range fun g => g • B) = Nat.card X := ncard_block_mul_ncard_orbit_eq hB h
hb : Set.ncard B ≥ 2
⊢ Set.ncard B * Set.ncard (Set.range fun g => g • B) ≥ 2 * Set.ncard (Set.range fun g => g • B) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : ¬Set.ncard B * Set.ncard (Set.range fun g => g • B) ≥ 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : Set.Nonempty B
hk : Set.ncard B * Set.ncard (Set.range fun g => g • B) = Nat.card X := ncard_block_mul_ncard_orbit_eq hB h
hb : Set.ncard B ≥ 2
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.is_subsingleton | [749, 1] | [769, 40] | refine' Nat.mul_le_mul_right _ hb | case inr.inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : ¬Set.ncard B * Set.ncard (Set.range fun g => g • B) ≥ 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : Set.Nonempty B
hk : Set.ncard B * Set.ncard (Set.range fun g => g • B) = Nat.card X := ncard_block_mul_ncard_orbit_eq hB h
hb : Set.ncard B ≥ 2
⊢ Set.ncard B * Set.ncard (Set.range fun g => g • B) ≥ 2 * Set.ncard (Set.range fun g => g • B) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
G : Type u_2
inst✝³ : Group G
X : Type u_1
inst✝² : MulAction G X
inst✝¹ : Finite X
inst✝ : IsPretransitive G X
B : Set X
hB : IsBlock G B
hB' : ¬Set.ncard B * Set.ncard (Set.range fun g => g • B) ≥ 2 * Set.ncard (Set.range fun g => g • B)
this : Fintype X
h : Set.Nonempty B
hk : Set.ncard B * Set.ncard (Set.range fun g => g • B) = Nat.card X := ncard_block_mul_ncard_orbit_eq hB h
hb : Set.ncard B ≥ 2
⊢ Set.ncard B * Set.ncard (Set.range fun g => g • B) ≥ 2 * Set.ncard (Set.range fun g => g • B)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | let B' := ⋂ (k : G) (_ : a ∈ k • B), k • B | G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
⊢ IsBlock G (⋂ k, ⋂ (_ : a ∈ k • B), k • B) | G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
⊢ IsBlock G (⋂ k, ⋂ (_ : a ∈ k • B), k • B) | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
⊢ IsBlock G (⋂ k, ⋂ (_ : a ∈ k • B), k • B)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | cases' Set.eq_empty_or_nonempty B with hfB_e hfB_ne | G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
⊢ IsBlock G (⋂ k, ⋂ (_ : a ∈ k • B), k • B) | case inl
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_e : B = ∅
⊢ IsBlock G (⋂ k, ⋂ (_ : a ∈ k • B), k • B)
case inr
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
⊢ IsBlock G (⋂ k, ⋂ (_ : a ∈ k • B), k • B) | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
⊢ IsBlock G (⋂ k, ⋂ (_ : a ∈ k • B), k • B)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | have hB'₀ : ∀ (k : G) (_ : a ∈ k • B), B' ≤ k • B := by
intro k hk
exact Set.biInter_subset_of_mem hk | case inr
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
⊢ IsBlock G (⋂ k, ⋂ (_ : a ∈ k • B), k • B) | case inr
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
⊢ IsBlock G (⋂ k, ⋂ (_ : a ∈ k • B), k • B) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
⊢ IsBlock G (⋂ k, ⋂ (_ : a ∈ k • B), k • B)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | have hfB' : B'.Finite := by
obtain ⟨b, hb : b ∈ B⟩ := hfB_ne
obtain ⟨k, hk : k • b = a⟩ := exists_smul_eq G b a
apply Set.Finite.subset (Set.Finite.map _ hfB) (hB'₀ k ⟨b, hb, hk⟩) | case inr
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
⊢ IsBlock G (⋂ k, ⋂ (_ : a ∈ k • B), k • B) | case inr
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
⊢ IsBlock G (⋂ k, ⋂ (_ : a ∈ k • B), k • B) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
⊢ IsBlock G (⋂ k, ⋂ (_ : a ∈ k • B), k • B)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | have hag' : ∀ g : G, a ∈ g • B' → B' = g • B' :=
by
intro g hg
apply symm
rw [← mem_stabilizer_iff]
rw [← Subgroup.inv_mem_iff (stabilizer G B')]
rw [mem_stabilizer_of_finite_iff_smul_le G B' hfB' g⁻¹]
rw [← Set.subset_set_smul_iff]
exact hag g hg | case inr
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
⊢ IsBlock G (⋂ k, ⋂ (_ : a ∈ k • B), k • B) | case inr
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
⊢ IsBlock G (⋂ k, ⋂ (_ : a ∈ k • B), k • B) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
⊢ IsBlock G (⋂ k, ⋂ (_ : a ∈ k • B), k • B)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | rw [IsBlock.mk_notempty_one] | case inr
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
⊢ IsBlock G (⋂ k, ⋂ (_ : a ∈ k • B), k • B) | case inr
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
⊢ ∀ (g : G),
(g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B ≠ ∅ →
g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
⊢ IsBlock G (⋂ k, ⋂ (_ : a ∈ k • B), k • B)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | intro g hg | case inr
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
⊢ ∀ (g : G),
(g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B ≠ ∅ →
g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B | case inr
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : (g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B ≠ ∅
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
⊢ ∀ (g : G),
(g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B ≠ ∅ →
g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | rw [← Set.nonempty_iff_ne_empty] at hg | case inr
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : (g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B ≠ ∅
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B | case inr
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : (g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B ≠ ∅
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | obtain ⟨b : X, hb' : b ∈ g • B', hb : b ∈ B'⟩ := Set.nonempty_def.mp hg | case inr
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B | case inr.intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | obtain ⟨k : G, hk : k • a = b⟩ := exists_smul_eq G a b | case inr.intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B | case inr.intro.intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | have hak : a ∈ k⁻¹ • B' := by
refine ⟨b, hb, ?_⟩
simp only [← hk, inv_smul_smul] | case inr.intro.intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B | case inr.intro.intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
hak : a ∈ k⁻¹ • B'
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | have hagk : a ∈ (k⁻¹ * g) • B' :=
by
rw [mul_smul, Set.mem_smul_set_iff_inv_smul_mem, inv_inv, hk]
exact hb' | case inr.intro.intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
hak : a ∈ k⁻¹ • B'
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B | case inr.intro.intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
hak : a ∈ k⁻¹ • B'
hagk : a ∈ (k⁻¹ * g) • B'
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
hak : a ∈ k⁻¹ • B'
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | have hkB' : B' = k⁻¹ • B' := hag' k⁻¹ hak | case inr.intro.intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
hak : a ∈ k⁻¹ • B'
hagk : a ∈ (k⁻¹ * g) • B'
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B | case inr.intro.intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
hak : a ∈ k⁻¹ • B'
hagk : a ∈ (k⁻¹ * g) • B'
hkB' : B' = k⁻¹ • B'
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
hak : a ∈ k⁻¹ • B'
hagk : a ∈ (k⁻¹ * g) • B'
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | have hgkB' : B' = (k⁻¹ * g) • B' := hag' (k⁻¹ * g) hagk | case inr.intro.intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
hak : a ∈ k⁻¹ • B'
hagk : a ∈ (k⁻¹ * g) • B'
hkB' : B' = k⁻¹ • B'
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B | case inr.intro.intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
hak : a ∈ k⁻¹ • B'
hagk : a ∈ (k⁻¹ * g) • B'
hkB' : B' = k⁻¹ • B'
hgkB' : B' = (k⁻¹ * g) • B'
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
hak : a ∈ k⁻¹ • B'
hagk : a ∈ (k⁻¹ * g) • B'
hkB' : B' = k⁻¹ • B'
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | rw [mul_smul] at hgkB' | case inr.intro.intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
hak : a ∈ k⁻¹ • B'
hagk : a ∈ (k⁻¹ * g) • B'
hkB' : B' = k⁻¹ • B'
hgkB' : B' = (k⁻¹ * g) • B'
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B | case inr.intro.intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
hak : a ∈ k⁻¹ • B'
hagk : a ∈ (k⁻¹ * g) • B'
hkB' : B' = k⁻¹ • B'
hgkB' : B' = k⁻¹ • g • B'
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
hak : a ∈ k⁻¹ • B'
hagk : a ∈ (k⁻¹ * g) • B'
hkB' : B' = k⁻¹ • B'
hgkB' : B' = (k⁻¹ * g) • B'
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | rw [← smul_eq_iff_eq_inv_smul] at hkB' hgkB' | case inr.intro.intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
hak : a ∈ k⁻¹ • B'
hagk : a ∈ (k⁻¹ * g) • B'
hkB' : B' = k⁻¹ • B'
hgkB' : B' = k⁻¹ • g • B'
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B | case inr.intro.intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
hak : a ∈ k⁻¹ • B'
hagk : a ∈ (k⁻¹ * g) • B'
hkB' : k • B' = B'
hgkB' : k • B' = g • B'
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
hak : a ∈ k⁻¹ • B'
hagk : a ∈ (k⁻¹ * g) • B'
hkB' : B' = k⁻¹ • B'
hgkB' : B' = k⁻¹ • g • B'
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | rw [← hgkB', hkB'] | case inr.intro.intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
hak : a ∈ k⁻¹ • B'
hagk : a ∈ (k⁻¹ * g) • B'
hkB' : k • B' = B'
hgkB' : k • B' = g • B'
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
hak : a ∈ k⁻¹ • B'
hagk : a ∈ (k⁻¹ * g) • B'
hkB' : k • B' = B'
hgkB' : k • B' = g • B'
⊢ g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B = ⋂ k, ⋂ (_ : a ∈ k • B), k • B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | suffices (⋂ (k : G) (_ : a ∈ k • B), k • B) = Set.univ by
rw [this]; apply top_IsBlock | case inl
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_e : B = ∅
⊢ IsBlock G (⋂ k, ⋂ (_ : a ∈ k • B), k • B) | case inl
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_e : B = ∅
⊢ ⋂ k, ⋂ (_ : a ∈ k • B), k • B = Set.univ | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_e : B = ∅
⊢ IsBlock G (⋂ k, ⋂ (_ : a ∈ k • B), k • B)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | simp only [Set.iInter_eq_univ] | case inl
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_e : B = ∅
⊢ ⋂ k, ⋂ (_ : a ∈ k • B), k • B = Set.univ | case inl
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_e : B = ∅
⊢ ∀ (i : G), a ∈ i • B → i • B = Set.univ | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_e : B = ∅
⊢ ⋂ k, ⋂ (_ : a ∈ k • B), k • B = Set.univ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | intro k hk | case inl
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_e : B = ∅
⊢ ∀ (i : G), a ∈ i • B → i • B = Set.univ | case inl
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_e : B = ∅
k : G
hk : a ∈ k • B
⊢ k • B = Set.univ | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_e : B = ∅
⊢ ∀ (i : G), a ∈ i • B → i • B = Set.univ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | exfalso | case inl
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_e : B = ∅
k : G
hk : a ∈ k • B
⊢ k • B = Set.univ | case inl
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_e : B = ∅
k : G
hk : a ∈ k • B
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_e : B = ∅
k : G
hk : a ∈ k • B
⊢ k • B = Set.univ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | rw [hfB_e] at hk | case inl
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_e : B = ∅
k : G
hk : a ∈ k • B
⊢ False | case inl
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_e : B = ∅
k : G
hk : a ∈ k • ∅
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_e : B = ∅
k : G
hk : a ∈ k • B
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | simpa only [Set.smul_set_empty] using hk | case inl
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_e : B = ∅
k : G
hk : a ∈ k • ∅
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_e : B = ∅
k : G
hk : a ∈ k • ∅
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | rw [this] | G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_e : B = ∅
this : ⋂ k, ⋂ (_ : a ∈ k • B), k • B = Set.univ
⊢ IsBlock G (⋂ k, ⋂ (_ : a ∈ k • B), k • B) | G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_e : B = ∅
this : ⋂ k, ⋂ (_ : a ∈ k • B), k • B = Set.univ
⊢ IsBlock G Set.univ | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_e : B = ∅
this : ⋂ k, ⋂ (_ : a ∈ k • B), k • B = Set.univ
⊢ IsBlock G (⋂ k, ⋂ (_ : a ∈ k • B), k • B)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | apply top_IsBlock | G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_e : B = ∅
this : ⋂ k, ⋂ (_ : a ∈ k • B), k • B = Set.univ
⊢ IsBlock G Set.univ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_e : B = ∅
this : ⋂ k, ⋂ (_ : a ∈ k • B), k • B = Set.univ
⊢ IsBlock G Set.univ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | intro k hk | G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
⊢ ∀ (k : G), a ∈ k • B → B' ≤ k • B | G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
k : G
hk : a ∈ k • B
⊢ B' ≤ k • B | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
⊢ ∀ (k : G), a ∈ k • B → B' ≤ k • B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | exact Set.biInter_subset_of_mem hk | G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
k : G
hk : a ∈ k • B
⊢ B' ≤ k • B | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
k : G
hk : a ∈ k • B
⊢ B' ≤ k • B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | obtain ⟨b, hb : b ∈ B⟩ := hfB_ne | G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
⊢ Set.Finite B' | case intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
b : X
hb : b ∈ B
⊢ Set.Finite B' | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
⊢ Set.Finite B'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | obtain ⟨k, hk : k • b = a⟩ := exists_smul_eq G b a | case intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
b : X
hb : b ∈ B
⊢ Set.Finite B' | case intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
b : X
hb : b ∈ B
k : G
hk : k • b = a
⊢ Set.Finite B' | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
b : X
hb : b ∈ B
⊢ Set.Finite B'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | apply Set.Finite.subset (Set.Finite.map _ hfB) (hB'₀ k ⟨b, hb, hk⟩) | case intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
b : X
hb : b ∈ B
k : G
hk : k • b = a
⊢ Set.Finite B' | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
b : X
hb : b ∈ B
k : G
hk : k • b = a
⊢ Set.Finite B'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | intro g hg x hx | G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
⊢ ∀ (g : G), a ∈ g • B' → B' ≤ g • B' | G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
⊢ x ∈ g • B' | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
⊢ ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | use g⁻¹ • x | G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
⊢ x ∈ g • B' | case h
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
⊢ g⁻¹ • x ∈ B' ∧ (fun x => g • x) (g⁻¹ • x) = x | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
⊢ x ∈ g • B'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | constructor | case h
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
⊢ g⁻¹ • x ∈ B' ∧ (fun x => g • x) (g⁻¹ • x) = x | case h.left
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
⊢ g⁻¹ • x ∈ B'
case h.right
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
⊢ (fun x => g • x) (g⁻¹ • x) = x | Please generate a tactic in lean4 to solve the state.
STATE:
case h
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
⊢ g⁻¹ • x ∈ B' ∧ (fun x => g • x) (g⁻¹ • x) = x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | apply Set.mem_biInter | case h.left
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
⊢ g⁻¹ • x ∈ B' | case h.left.h
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
⊢ ∀ x_1 ∈ fun x => (x • B) a, g⁻¹ • x ∈ x_1 • B | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
⊢ g⁻¹ • x ∈ B'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | intro k | case h.left.h
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
⊢ ∀ x_1 ∈ fun x => (x • B) a, g⁻¹ • x ∈ x_1 • B | case h.left.h
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
⊢ (k ∈ fun x => (x • B) a) → g⁻¹ • x ∈ k • B | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.h
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
⊢ ∀ x_1 ∈ fun x => (x • B) a, g⁻¹ • x ∈ x_1 • B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | rintro (hk : a ∈ k • B) | case h.left.h
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
⊢ (k ∈ fun x => (x • B) a) → g⁻¹ • x ∈ k • B | case h.left.h
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ g⁻¹ • x ∈ k • B | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.h
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
⊢ (k ∈ fun x => (x • B) a) → g⁻¹ • x ∈ k • B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | rw [← Set.mem_smul_set_iff_inv_smul_mem, smul_smul] | case h.left.h
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ g⁻¹ • x ∈ k • B | case h.left.h
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ x ∈ (g * k) • B | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.h
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ g⁻¹ • x ∈ k • B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | apply hB'₀ | case h.left.h
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ x ∈ (g * k) • B | case h.left.h.x
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ a ∈ (g * k) • B
case h.left.h.a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ x ∈ B' | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.h
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ x ∈ (g * k) • B
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | rw [← smul_smul, Set.mem_smul_set_iff_inv_smul_mem] | case h.left.h.x
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ a ∈ (g * k) • B
case h.left.h.a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ x ∈ B' | case h.left.h.x
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ g⁻¹ • a ∈ k • B
case h.left.h.a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ x ∈ B' | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.h.x
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ a ∈ (g * k) • B
case h.left.h.a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ x ∈ B'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | apply hB'₀ k hk | case h.left.h.x
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ g⁻¹ • a ∈ k • B
case h.left.h.a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ x ∈ B' | case h.left.h.x.a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ g⁻¹ • a ∈ B'
case h.left.h.a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ x ∈ B' | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.h.x
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ g⁻¹ • a ∈ k • B
case h.left.h.a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ x ∈ B'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | rw [← Set.mem_smul_set_iff_inv_smul_mem] | case h.left.h.x.a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ g⁻¹ • a ∈ B'
case h.left.h.a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ x ∈ B' | case h.left.h.x.a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ a ∈ g • B'
case h.left.h.a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ x ∈ B' | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.h.x.a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ g⁻¹ • a ∈ B'
case h.left.h.a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ x ∈ B'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | exact hg | case h.left.h.x.a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ a ∈ g • B'
case h.left.h.a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ x ∈ B' | case h.left.h.a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ x ∈ B' | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.h.x.a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ a ∈ g • B'
case h.left.h.a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ x ∈ B'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | exact hx | case h.left.h.a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ x ∈ B' | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.h.a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
k : G
hk : a ∈ k • B
⊢ x ∈ B'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | simp only [smul_inv_smul] | case h.right
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
⊢ (fun x => g • x) (g⁻¹ • x) = x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
g : G
hg : a ∈ g • B'
x : X
hx : x ∈ B'
⊢ (fun x => g • x) (g⁻¹ • x) = x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | intro g hg | G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
⊢ ∀ (g : G), a ∈ g • B' → B' = g • B' | G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
g : G
hg : a ∈ g • B'
⊢ B' = g • B' | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
⊢ ∀ (g : G), a ∈ g • B' → B' = g • B'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | apply symm | G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
g : G
hg : a ∈ g • B'
⊢ B' = g • B' | case a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
g : G
hg : a ∈ g • B'
⊢ g • B' = B' | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
g : G
hg : a ∈ g • B'
⊢ B' = g • B'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | rw [← mem_stabilizer_iff] | case a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
g : G
hg : a ∈ g • B'
⊢ g • B' = B' | case a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
g : G
hg : a ∈ g • B'
⊢ g ∈ stabilizer G B' | Please generate a tactic in lean4 to solve the state.
STATE:
case a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
g : G
hg : a ∈ g • B'
⊢ g • B' = B'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | rw [← Subgroup.inv_mem_iff (stabilizer G B')] | case a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
g : G
hg : a ∈ g • B'
⊢ g ∈ stabilizer G B' | case a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
g : G
hg : a ∈ g • B'
⊢ g⁻¹ ∈ stabilizer G B' | Please generate a tactic in lean4 to solve the state.
STATE:
case a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
g : G
hg : a ∈ g • B'
⊢ g ∈ stabilizer G B'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | rw [mem_stabilizer_of_finite_iff_smul_le G B' hfB' g⁻¹] | case a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
g : G
hg : a ∈ g • B'
⊢ g⁻¹ ∈ stabilizer G B' | case a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
g : G
hg : a ∈ g • B'
⊢ g⁻¹ • B' ⊆ B' | Please generate a tactic in lean4 to solve the state.
STATE:
case a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
g : G
hg : a ∈ g • B'
⊢ g⁻¹ ∈ stabilizer G B'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | rw [← Set.subset_set_smul_iff] | case a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
g : G
hg : a ∈ g • B'
⊢ g⁻¹ • B' ⊆ B' | case a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
g : G
hg : a ∈ g • B'
⊢ B' ⊆ g • B' | Please generate a tactic in lean4 to solve the state.
STATE:
case a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
g : G
hg : a ∈ g • B'
⊢ g⁻¹ • B' ⊆ B'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | exact hag g hg | case a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
g : G
hg : a ∈ g • B'
⊢ B' ⊆ g • B' | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
g : G
hg : a ∈ g • B'
⊢ B' ⊆ g • B'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | refine ⟨b, hb, ?_⟩ | G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
⊢ a ∈ k⁻¹ • B' | G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
⊢ (fun x => k⁻¹ • x) b = a | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
⊢ a ∈ k⁻¹ • B'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | simp only [← hk, inv_smul_smul] | G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
⊢ (fun x => k⁻¹ • x) b = a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
⊢ (fun x => k⁻¹ • x) b = a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | rw [mul_smul, Set.mem_smul_set_iff_inv_smul_mem, inv_inv, hk] | G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
hak : a ∈ k⁻¹ • B'
⊢ a ∈ (k⁻¹ * g) • B' | G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
hak : a ∈ k⁻¹ • B'
⊢ b ∈ g • B' | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
hak : a ∈ k⁻¹ • B'
⊢ a ∈ (k⁻¹ * g) • B'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Blocks.lean | MulAction.IsBlock.of_subset | [775, 1] | [833, 21] | exact hb' | G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
hak : a ∈ k⁻¹ • B'
⊢ b ∈ g • B' | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
G : Type u_2
inst✝² : Group G
X : Type u_1
inst✝¹ : MulAction G X
inst✝ : IsPretransitive G X
a : X
B : Set X
hfB : Set.Finite B
B' : Set X := ⋂ k, ⋂ (_ : a ∈ k • B), k • B
hfB_ne : Set.Nonempty B
hB'₀ : ∀ (k : G), a ∈ k • B → B' ≤ k • B
hfB' : Set.Finite B'
hag : ∀ (g : G), a ∈ g • B' → B' ≤ g • B'
hag' : ∀ (g : G), a ∈ g • B' → B' = g • B'
g : G
hg : Set.Nonempty ((g • ⋂ k, ⋂ (_ : a ∈ k • B), k • B) ∩ ⋂ k, ⋂ (_ : a ∈ k • B), k • B)
b : X
hb' : b ∈ g • B'
hb : b ∈ B'
k : G
hk : k • a = b
hak : a ∈ k⁻¹ • B'
⊢ b ∈ g • B'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Iwasawa.lean | commutator_le_iwasawa | [55, 1] | [69, 93] | have is_transN := is_qprim.pretransitive_of_normal nN hNX | M : Type u_2
inst✝¹ : Group M
α : Type u_1
inst✝ : MulAction M α
is_qprim : IsQuasipreprimitive M α
IwaS : IwasawaStructure M α
N : Subgroup M
nN : Subgroup.Normal N
hNX : MulAction.fixedPoints (↥N) α ≠ ⊤
⊢ commutator M ≤ N | M : Type u_2
inst✝¹ : Group M
α : Type u_1
inst✝ : MulAction M α
is_qprim : IsQuasipreprimitive M α
IwaS : IwasawaStructure M α
N : Subgroup M
nN : Subgroup.Normal N
hNX : MulAction.fixedPoints (↥N) α ≠ ⊤
is_transN : MulAction.IsPretransitive (↥N) α
⊢ commutator M ≤ N | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
inst✝¹ : Group M
α : Type u_1
inst✝ : MulAction M α
is_qprim : IsQuasipreprimitive M α
IwaS : IwasawaStructure M α
N : Subgroup M
nN : Subgroup.Normal N
hNX : MulAction.fixedPoints (↥N) α ≠ ⊤
⊢ commutator M ≤ N
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Iwasawa.lean | commutator_le_iwasawa | [55, 1] | [69, 93] | have ntα : Nontrivial α := isnontrivial_of_nontrivial_action hNX | M : Type u_2
inst✝¹ : Group M
α : Type u_1
inst✝ : MulAction M α
is_qprim : IsQuasipreprimitive M α
IwaS : IwasawaStructure M α
N : Subgroup M
nN : Subgroup.Normal N
hNX : MulAction.fixedPoints (↥N) α ≠ ⊤
is_transN : MulAction.IsPretransitive (↥N) α
⊢ commutator M ≤ N | M : Type u_2
inst✝¹ : Group M
α : Type u_1
inst✝ : MulAction M α
is_qprim : IsQuasipreprimitive M α
IwaS : IwasawaStructure M α
N : Subgroup M
nN : Subgroup.Normal N
hNX : MulAction.fixedPoints (↥N) α ≠ ⊤
is_transN : MulAction.IsPretransitive (↥N) α
ntα : Nontrivial α
⊢ commutator M ≤ N | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
inst✝¹ : Group M
α : Type u_1
inst✝ : MulAction M α
is_qprim : IsQuasipreprimitive M α
IwaS : IwasawaStructure M α
N : Subgroup M
nN : Subgroup.Normal N
hNX : MulAction.fixedPoints (↥N) α ≠ ⊤
is_transN : MulAction.IsPretransitive (↥N) α
⊢ commutator M ≤ N
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Iwasawa.lean | commutator_le_iwasawa | [55, 1] | [69, 93] | obtain a : α := Nontrivial.to_nonempty.some | M : Type u_2
inst✝¹ : Group M
α : Type u_1
inst✝ : MulAction M α
is_qprim : IsQuasipreprimitive M α
IwaS : IwasawaStructure M α
N : Subgroup M
nN : Subgroup.Normal N
hNX : MulAction.fixedPoints (↥N) α ≠ ⊤
is_transN : MulAction.IsPretransitive (↥N) α
ntα : Nontrivial α
⊢ commutator M ≤ N | M : Type u_2
inst✝¹ : Group M
α : Type u_1
inst✝ : MulAction M α
is_qprim : IsQuasipreprimitive M α
IwaS : IwasawaStructure M α
N : Subgroup M
nN : Subgroup.Normal N
hNX : MulAction.fixedPoints (↥N) α ≠ ⊤
is_transN : MulAction.IsPretransitive (↥N) α
ntα : Nontrivial α
a : α
⊢ commutator M ≤ N | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
inst✝¹ : Group M
α : Type u_1
inst✝ : MulAction M α
is_qprim : IsQuasipreprimitive M α
IwaS : IwasawaStructure M α
N : Subgroup M
nN : Subgroup.Normal N
hNX : MulAction.fixedPoints (↥N) α ≠ ⊤
is_transN : MulAction.IsPretransitive (↥N) α
ntα : Nontrivial α
⊢ commutator M ≤ N
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Iwasawa.lean | commutator_le_iwasawa | [55, 1] | [69, 93] | refine' contains_commutators_of N nN (IwaS.T a) _ (IwaS.is_comm a) | M : Type u_2
inst✝¹ : Group M
α : Type u_1
inst✝ : MulAction M α
is_qprim : IsQuasipreprimitive M α
IwaS : IwasawaStructure M α
N : Subgroup M
nN : Subgroup.Normal N
hNX : MulAction.fixedPoints (↥N) α ≠ ⊤
is_transN : MulAction.IsPretransitive (↥N) α
ntα : Nontrivial α
a : α
⊢ commutator M ≤ N | M : Type u_2
inst✝¹ : Group M
α : Type u_1
inst✝ : MulAction M α
is_qprim : IsQuasipreprimitive M α
IwaS : IwasawaStructure M α
N : Subgroup M
nN : Subgroup.Normal N
hNX : MulAction.fixedPoints (↥N) α ≠ ⊤
is_transN : MulAction.IsPretransitive (↥N) α
ntα : Nontrivial α
a : α
⊢ N ⊔ IwaS.T a = ⊤ | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
inst✝¹ : Group M
α : Type u_1
inst✝ : MulAction M α
is_qprim : IsQuasipreprimitive M α
IwaS : IwasawaStructure M α
N : Subgroup M
nN : Subgroup.Normal N
hNX : MulAction.fixedPoints (↥N) α ≠ ⊤
is_transN : MulAction.IsPretransitive (↥N) α
ntα : Nontrivial α
a : α
⊢ commutator M ≤ N
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Iwasawa.lean | commutator_le_iwasawa | [55, 1] | [69, 93] | rw [eq_top_iff, ← IwaS.is_generator, iSup_le_iff] | M : Type u_2
inst✝¹ : Group M
α : Type u_1
inst✝ : MulAction M α
is_qprim : IsQuasipreprimitive M α
IwaS : IwasawaStructure M α
N : Subgroup M
nN : Subgroup.Normal N
hNX : MulAction.fixedPoints (↥N) α ≠ ⊤
is_transN : MulAction.IsPretransitive (↥N) α
ntα : Nontrivial α
a : α
⊢ N ⊔ IwaS.T a = ⊤ | M : Type u_2
inst✝¹ : Group M
α : Type u_1
inst✝ : MulAction M α
is_qprim : IsQuasipreprimitive M α
IwaS : IwasawaStructure M α
N : Subgroup M
nN : Subgroup.Normal N
hNX : MulAction.fixedPoints (↥N) α ≠ ⊤
is_transN : MulAction.IsPretransitive (↥N) α
ntα : Nontrivial α
a : α
⊢ ∀ (i : α), IwaS.T i ≤ N ⊔ IwaS.T a | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
inst✝¹ : Group M
α : Type u_1
inst✝ : MulAction M α
is_qprim : IsQuasipreprimitive M α
IwaS : IwasawaStructure M α
N : Subgroup M
nN : Subgroup.Normal N
hNX : MulAction.fixedPoints (↥N) α ≠ ⊤
is_transN : MulAction.IsPretransitive (↥N) α
ntα : Nontrivial α
a : α
⊢ N ⊔ IwaS.T a = ⊤
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.