url stringclasses 147
values | commit stringclasses 147
values | file_path stringlengths 7 101 | full_name stringlengths 1 94 | start stringlengths 6 10 | end stringlengths 6 11 | tactic stringlengths 1 11.2k | state_before stringlengths 3 2.09M | state_after stringlengths 6 2.09M | input stringlengths 73 2.09M |
|---|---|---|---|---|---|---|---|---|---|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_surjective_map | [200, 1] | [223, 68] | simp only [← aux_apply, ← hg, smul_apply, MulActionHom.map_smul'] | case h.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
aux_apply : ∀ (x : Fin n ↪ β) (i : Fin n), f.toFun ((aux x) i) = x i
x y : Fin n ↪ β
g : M
hg : ∀ (x_1 : Fin n), (g • aux x) x_1 = (aux y) x_1
i : Fin n
⊢ σ g • x i = y i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
aux_apply : ∀ (x : Fin n ↪ β) (i : Fin n), f.toFun ((aux x) i) = x i
x y : Fin n ↪ β
g : M
hg : ∀ (x_1 : Fin n), (g • aux x) x_1 = (aux y) x_1
i : Fin n
⊢ σ g • x i = y i
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_surjective_map | [200, 1] | [223, 68] | let huv' :=congr_arg f huv | M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x : Fin n ↪ β
u v : Fin n
huv : (Function.surjInv hf ∘ x.toFun) u = (Function.surjInv hf ∘ x.toFun) v
⊢ u = v | M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x : Fin n ↪ β
u v : Fin n
huv : (Function.surjInv hf ∘ x.toFun) u = (Function.surjInv hf ∘ x.toFun) v
huv' : f ((Function.surjInv hf ∘ x.toFun) u) = f ((Function.surjInv hf ∘ x.toFun) v) := congr_arg (⇑f) huv
⊢ u = v | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x : Fin n ↪ β
u v : Fin n
huv : (Function.surjInv hf ∘ x.toFun) u = (Function.surjInv hf ∘ x.toFun) v
⊢ u = v
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_surjective_map | [200, 1] | [223, 68] | simp only [Function.comp_apply, Function.surjInv_eq] at huv' | M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x : Fin n ↪ β
u v : Fin n
huv : (Function.surjInv hf ∘ x.toFun) u = (Function.surjInv hf ∘ x.toFun) v
huv' : f ((Function.surjInv hf ∘ x.toFun) u) = f ((Function.surjInv hf ∘ x.toFun) v) := congr_arg (⇑f) huv
⊢ u = v | M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x : Fin n ↪ β
u v : Fin n
huv : (Function.surjInv hf ∘ x.toFun) u = (Function.surjInv hf ∘ x.toFun) v
huv' : x.toFun u = x.toFun v
⊢ u = v | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x : Fin n ↪ β
u v : Fin n
huv : (Function.surjInv hf ∘ x.toFun) u = (Function.surjInv hf ∘ x.toFun) v
huv' : f ((Function.surjInv hf ∘ x.toFun) u) = f ((Function.surjInv hf ∘ x.toFun) v) := congr_arg (⇑f) huv
⊢ u = v
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_surjective_map | [200, 1] | [223, 68] | exact x.inj' huv' | M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x : Fin n ↪ β
u v : Fin n
huv : (Function.surjInv hf ∘ x.toFun) u = (Function.surjInv hf ∘ x.toFun) v
huv' : x.toFun u = x.toFun v
⊢ u = v | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x : Fin n ↪ β
u v : Fin n
huv : (Function.surjInv hf ∘ x.toFun) u = (Function.surjInv hf ∘ x.toFun) v
huv' : x.toFun u = x.toFun v
⊢ u = v
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_surjective_map | [200, 1] | [223, 68] | simp only [toFun_eq_coe, coeFn_mk, Function.comp_apply, aux] | M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
x : Fin n ↪ β
i : Fin n
⊢ f.toFun ((aux x) i) = x i | M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
x : Fin n ↪ β
i : Fin n
⊢ f.toFun (Function.surjInv hf (x i)) = x i | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
x : Fin n ↪ β
i : Fin n
⊢ f.toFun ((aux x) i) = x i
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_surjective_map | [200, 1] | [223, 68] | apply Function.surjInv_eq | M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
x : Fin n ↪ β
i : Fin n
⊢ f.toFun (Function.surjInv hf (x i)) = x i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
x : Fin n ↪ β
i : Fin n
⊢ f.toFun (Function.surjInv hf (x i)) = x i
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_bijective_map_iff | [226, 1] | [245, 69] | constructor | M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
⊢ IsMultiplyPretransitive M α n ↔ IsMultiplyPretransitive N β n | case mp
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
⊢ IsMultiplyPretransitive M α n → IsMultiplyPretransitive N β n
case mpr
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
⊢ IsMultiplyPretransitive N β n → IsMultiplyPretransitive M α n | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
⊢ IsMultiplyPretransitive M α n ↔ IsMultiplyPretransitive N β n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_bijective_map_iff | [226, 1] | [245, 69] | intro hN | case mpr
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
⊢ IsMultiplyPretransitive N β n → IsMultiplyPretransitive M α n | case mpr
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
⊢ IsMultiplyPretransitive M α n | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
⊢ IsMultiplyPretransitive N β n → IsMultiplyPretransitive M α n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_bijective_map_iff | [226, 1] | [245, 69] | let hN_heq := hN.exists_smul_eq | case mpr
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
⊢ IsMultiplyPretransitive M α n | case mpr
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ IsMultiplyPretransitive M α n | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
⊢ IsMultiplyPretransitive M α n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_bijective_map_iff | [226, 1] | [245, 69] | apply IsPretransitive.mk | case mpr
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ IsMultiplyPretransitive M α n | case mpr.exists_smul_eq
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (x y : Fin n ↪ α), ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ IsMultiplyPretransitive M α n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_bijective_map_iff | [226, 1] | [245, 69] | intro x y | case mpr.exists_smul_eq
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (x y : Fin n ↪ α), ∃ g, g • x = y | case mpr.exists_smul_eq
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.exists_smul_eq
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (x y : Fin n ↪ α), ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_bijective_map_iff | [226, 1] | [245, 69] | let x' : Fin n ↪ β := ⟨f ∘ x, hf.injective.comp x.inj'⟩ | case mpr.exists_smul_eq
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
⊢ ∃ g, g • x = y | case mpr.exists_smul_eq
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.exists_smul_eq
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_bijective_map_iff | [226, 1] | [245, 69] | let y' : Fin n ↪ β := ⟨f ∘ y, hf.injective.comp y.inj'⟩ | case mpr.exists_smul_eq
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
⊢ ∃ g, g • x = y | case mpr.exists_smul_eq
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
y' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑y, inj' := ⋯ }
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.exists_smul_eq
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_bijective_map_iff | [226, 1] | [245, 69] | obtain ⟨g', hg'⟩ := hN_heq x' y' | case mpr.exists_smul_eq
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
y' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑y, inj' := ⋯ }
⊢ ∃ g, g • x = y | case mpr.exists_smul_eq.intro
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
y' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑y, inj' := ⋯ }
g' : N
hg' : g' • x' = y'
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.exists_smul_eq
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
y' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑y, inj' := ⋯ }
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_bijective_map_iff | [226, 1] | [245, 69] | obtain ⟨g, hg⟩ := hσ g' | case mpr.exists_smul_eq.intro
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
y' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑y, inj' := ⋯ }
g' : N
hg' : g' • x' = y'
⊢ ∃ g, g • x = y | case mpr.exists_smul_eq.intro.intro
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
y' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑y, inj' := ⋯ }
g' : N
hg' : g' • x' = y'
g : M
hg : σ g = g'
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.exists_smul_eq.intro
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
y' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑y, inj' := ⋯ }
g' : N
hg' : g' • x' = y'
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_bijective_map_iff | [226, 1] | [245, 69] | use g | case mpr.exists_smul_eq.intro.intro
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
y' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑y, inj' := ⋯ }
g' : N
hg' : g' • x' = y'
g : M
hg : σ g = g'
⊢ ∃ g, g • x = y | case h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
y' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑y, inj' := ⋯ }
g' : N
hg' : g' • x' = y'
g : M
hg : σ g = g'
⊢ g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.exists_smul_eq.intro.intro
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
y' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑y, inj' := ⋯ }
g' : N
hg' : g' • x' = y'
g : M
hg : σ g = g'
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_bijective_map_iff | [226, 1] | [245, 69] | ext i | case h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
y' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑y, inj' := ⋯ }
g' : N
hg' : g' • x' = y'
g : M
hg : σ g = g'
⊢ g • x = y | case h.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
y' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑y, inj' := ⋯ }
g' : N
hg' : g' • x' = y'
g : M
hg : σ g = g'
i : Fin n
⊢ (g • x) i = y i | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
y' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑y, inj' := ⋯ }
g' : N
hg' : g' • x' = y'
g : M
hg : σ g = g'
⊢ g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_bijective_map_iff | [226, 1] | [245, 69] | apply hf.injective | case h.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
y' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑y, inj' := ⋯ }
g' : N
hg' : g' • x' = y'
g : M
hg : σ g = g'
i : Fin n
⊢ (g • x) i = y i | case h.h.a
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
y' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑y, inj' := ⋯ }
g' : N
hg' : g' • x' = y'
g : M
hg : σ g = g'
i : Fin n
⊢ f ((g • x) i) = f (y i) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
y' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑y, inj' := ⋯ }
g' : N
hg' : g' • x' = y'
g : M
hg : σ g = g'
i : Fin n
⊢ (g • x) i = y i
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_bijective_map_iff | [226, 1] | [245, 69] | simp only [smul_apply, map_smulₛₗ, hg] | case h.h.a
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
y' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑y, inj' := ⋯ }
g' : N
hg' : g' • x' = y'
g : M
hg : σ g = g'
i : Fin n
⊢ f ((g • x) i) = f (y i) | case h.h.a
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
y' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑y, inj' := ⋯ }
g' : N
hg' : g' • x' = y'
g : M
hg : σ g = g'
i : Fin n
⊢ g' • f (x i) = f (y i) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.a
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
y' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑y, inj' := ⋯ }
g' : N
hg' : g' • x' = y'
g : M
hg : σ g = g'
i : Fin n
⊢ f ((g • x) i) = f (y i)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_bijective_map_iff | [226, 1] | [245, 69] | change g' • (x' i) = y' i | case h.h.a
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
y' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑y, inj' := ⋯ }
g' : N
hg' : g' • x' = y'
g : M
hg : σ g = g'
i : Fin n
⊢ g' • f (x i) = f (y i) | case h.h.a
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
y' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑y, inj' := ⋯ }
g' : N
hg' : g' • x' = y'
g : M
hg : σ g = g'
i : Fin n
⊢ g' • x' i = y' i | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.a
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
y' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑y, inj' := ⋯ }
g' : N
hg' : g' • x' = y'
g : M
hg : σ g = g'
i : Fin n
⊢ g' • f (x i) = f (y i)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_bijective_map_iff | [226, 1] | [245, 69] | simp only [← hg, coeFn_mk, Function.comp_apply, ← hg', smul_apply] | case h.h.a
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
y' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑y, inj' := ⋯ }
g' : N
hg' : g' • x' = y'
g : M
hg : σ g = g'
i : Fin n
⊢ g' • x' i = y' i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.a
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
hN : IsMultiplyPretransitive N β n
hN_heq : ∀ (x y : Fin n ↪ β), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin n ↪ α
x' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑x, inj' := ⋯ }
y' : Fin n ↪ β := { toFun := ⇑f ∘ ⇑y, inj' := ⋯ }
g' : N
hg' : g' • x' = y'
g : M
hg : σ g = g'
i : Fin n
⊢ g' • x' i = y' i
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_bijective_map_iff | [226, 1] | [245, 69] | apply isMultiplyPretransitive_of_surjective_map hf.surjective | case mp
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
⊢ IsMultiplyPretransitive M α n → IsMultiplyPretransitive N β n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hσ : Function.Surjective σ
hf : Function.Bijective ⇑f
⊢ IsMultiplyPretransitive M α n → IsMultiplyPretransitive N β n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_zero_pretransitive | [340, 1] | [345, 24] | apply IsPretransitive.mk | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
⊢ IsMultiplyPretransitive M α 0 | case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
⊢ ∀ (x y : Fin 0 ↪ α), ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
⊢ IsMultiplyPretransitive M α 0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_zero_pretransitive | [340, 1] | [345, 24] | intro x y | case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
⊢ ∀ (x y : Fin 0 ↪ α), ∃ g, g • x = y | case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
x y : Fin 0 ↪ α
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
⊢ ∀ (x y : Fin 0 ↪ α), ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_zero_pretransitive | [340, 1] | [345, 24] | use 1 | case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
x y : Fin 0 ↪ α
⊢ ∃ g, g • x = y | case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
x y : Fin 0 ↪ α
⊢ 1 • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
x y : Fin 0 ↪ α
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_zero_pretransitive | [340, 1] | [345, 24] | rw [one_smul] | case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
x y : Fin 0 ↪ α
⊢ 1 • x = y | case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
x y : Fin 0 ↪ α
⊢ x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
x y : Fin 0 ↪ α
⊢ 1 • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_zero_pretransitive | [340, 1] | [345, 24] | ext i | case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
x y : Fin 0 ↪ α
⊢ x = y | case h.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
x y : Fin 0 ↪ α
i : Fin 0
⊢ x i = y i | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
x y : Fin 0 ↪ α
⊢ x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_zero_pretransitive | [340, 1] | [345, 24] | exfalso | case h.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
x y : Fin 0 ↪ α
i : Fin 0
⊢ x i = y i | case h.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
x y : Fin 0 ↪ α
i : Fin 0
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
x y : Fin 0 ↪ α
i : Fin 0
⊢ x i = y i
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_zero_pretransitive | [340, 1] | [345, 24] | exact IsEmpty.false i | case h.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
x y : Fin 0 ↪ α
i : Fin 0
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
x y : Fin 0 ↪ α
i : Fin 0
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isPretransitive_iff_is_one_pretransitive | [349, 1] | [353, 95] | unfold IsMultiplyPretransitive | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
⊢ IsPretransitive M α ↔ IsMultiplyPretransitive M α 1 | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
⊢ IsPretransitive M α ↔ IsPretransitive M (Fin 1 ↪ α) | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
⊢ IsPretransitive M α ↔ IsMultiplyPretransitive M α 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isPretransitive_iff_is_one_pretransitive | [349, 1] | [353, 95] | rw [isPretransitive.of_bijective_map_iff Function.surjective_id (finOneToMap_bijective M α)] | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
⊢ IsPretransitive M α ↔ IsPretransitive M (Fin 1 ↪ α) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
⊢ IsPretransitive M α ↔ IsPretransitive M (Fin 1 ↪ α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | have : ∀ i : Fin 2, i = 0 ∨ i = 1 := by
rintro ⟨i, hi⟩
by_cases hi' : i = 0
apply Or.intro_left
apply Fin.eq_of_val_eq
simp only [Fin.val_zero, hi']
apply Or.intro_right
apply Fin.eq_of_val_eq
simp only [Fin.val_one]
apply Nat.eq_of_lt_succ_of_not_lt
exact hi; simp only [lt_one_iff]; exact hi' | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
⊢ IsMultiplyPretransitive M α 2 ↔ ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
⊢ IsMultiplyPretransitive M α 2 ↔ ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
⊢ IsMultiplyPretransitive M α 2 ↔ ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | let f : ∀ (a b : α) (_ : a ≠ b), Fin 2 ↪ α := fun a b hab =>
⟨fun i => ite (i = 0) a b, by
intro i j hij
by_cases hi : i = 0
by_cases hj : j = 0
rw [hi, hj]
simp only [if_pos hi, if_neg hj] at hij ; exfalso; exact hab hij
by_cases hj : j = 0
simp only [if_neg hi, if_pos hj] at hij ; exfalso; exact hab hij.symm
rw [Or.resolve_left (this i) hi, Or.resolve_left (this j) hj]⟩ | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
⊢ IsMultiplyPretransitive M α 2 ↔ ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
⊢ IsMultiplyPretransitive M α 2 ↔ ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
⊢ IsMultiplyPretransitive M α 2 ↔ ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | constructor | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
⊢ IsMultiplyPretransitive M α 2 ↔ ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d | case mp
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
⊢ IsMultiplyPretransitive M α 2 → ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
case mpr
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
⊢ (∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d) → IsMultiplyPretransitive M α 2 | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
⊢ IsMultiplyPretransitive M α 2 ↔ ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | rintro ⟨i, hi⟩ | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
⊢ ∀ (i : Fin 2), i = 0 ∨ i = 1 | case mk
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
⊢ { val := i, isLt := hi } = 0 ∨ { val := i, isLt := hi } = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
⊢ ∀ (i : Fin 2), i = 0 ∨ i = 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | by_cases hi' : i = 0 | case mk
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
⊢ { val := i, isLt := hi } = 0 ∨ { val := i, isLt := hi } = 1 | case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : i = 0
⊢ { val := i, isLt := hi } = 0 ∨ { val := i, isLt := hi } = 1
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ { val := i, isLt := hi } = 0 ∨ { val := i, isLt := hi } = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case mk
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
⊢ { val := i, isLt := hi } = 0 ∨ { val := i, isLt := hi } = 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | apply Or.intro_left | case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : i = 0
⊢ { val := i, isLt := hi } = 0 ∨ { val := i, isLt := hi } = 1
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ { val := i, isLt := hi } = 0 ∨ { val := i, isLt := hi } = 1 | case pos.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : i = 0
⊢ { val := i, isLt := hi } = 0
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ { val := i, isLt := hi } = 0 ∨ { val := i, isLt := hi } = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : i = 0
⊢ { val := i, isLt := hi } = 0 ∨ { val := i, isLt := hi } = 1
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ { val := i, isLt := hi } = 0 ∨ { val := i, isLt := hi } = 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | apply Fin.eq_of_val_eq | case pos.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : i = 0
⊢ { val := i, isLt := hi } = 0
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ { val := i, isLt := hi } = 0 ∨ { val := i, isLt := hi } = 1 | case pos.h.a
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : i = 0
⊢ ↑{ val := i, isLt := hi } = ↑0
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ { val := i, isLt := hi } = 0 ∨ { val := i, isLt := hi } = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : i = 0
⊢ { val := i, isLt := hi } = 0
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ { val := i, isLt := hi } = 0 ∨ { val := i, isLt := hi } = 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | simp only [Fin.val_zero, hi'] | case pos.h.a
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : i = 0
⊢ ↑{ val := i, isLt := hi } = ↑0
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ { val := i, isLt := hi } = 0 ∨ { val := i, isLt := hi } = 1 | case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ { val := i, isLt := hi } = 0 ∨ { val := i, isLt := hi } = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.h.a
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : i = 0
⊢ ↑{ val := i, isLt := hi } = ↑0
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ { val := i, isLt := hi } = 0 ∨ { val := i, isLt := hi } = 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | apply Or.intro_right | case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ { val := i, isLt := hi } = 0 ∨ { val := i, isLt := hi } = 1 | case neg.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ { val := i, isLt := hi } = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ { val := i, isLt := hi } = 0 ∨ { val := i, isLt := hi } = 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | apply Fin.eq_of_val_eq | case neg.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ { val := i, isLt := hi } = 1 | case neg.h.a
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ ↑{ val := i, isLt := hi } = ↑1 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ { val := i, isLt := hi } = 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | simp only [Fin.val_one] | case neg.h.a
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ ↑{ val := i, isLt := hi } = ↑1 | case neg.h.a
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ i = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.h.a
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ ↑{ val := i, isLt := hi } = ↑1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | apply Nat.eq_of_lt_succ_of_not_lt | case neg.h.a
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ i = 1 | case neg.h.a.hmn
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ i < 1 + 1
case neg.h.a.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ ¬i < 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.h.a
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ i = 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | exact hi | case neg.h.a.hmn
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ i < 1 + 1
case neg.h.a.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ ¬i < 1 | case neg.h.a.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ ¬i < 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.h.a.hmn
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ i < 1 + 1
case neg.h.a.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ ¬i < 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | simp only [lt_one_iff] | case neg.h.a.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ ¬i < 1 | case neg.h.a.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ ¬i = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.h.a.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ ¬i < 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | exact hi' | case neg.h.a.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ ¬i = 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.h.a.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
i : ℕ
hi : i < 2
hi' : ¬i = 0
⊢ ¬i = 0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | intro i j hij | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
⊢ Function.Injective fun i => if i = 0 then a else b | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
⊢ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
⊢ Function.Injective fun i => if i = 0 then a else b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | by_cases hi : i = 0 | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
⊢ i = j | case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : i = 0
⊢ i = j
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
⊢ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
⊢ i = j
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | by_cases hj : j = 0 | case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : i = 0
⊢ i = j
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
⊢ i = j | case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : i = 0
hj : j = 0
⊢ i = j
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : i = 0
hj : ¬j = 0
⊢ i = j
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
⊢ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : i = 0
⊢ i = j
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
⊢ i = j
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | rw [hi, hj] | case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : i = 0
hj : j = 0
⊢ i = j
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : i = 0
hj : ¬j = 0
⊢ i = j
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
⊢ i = j | case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : i = 0
hj : ¬j = 0
⊢ i = j
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
⊢ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : i = 0
hj : j = 0
⊢ i = j
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : i = 0
hj : ¬j = 0
⊢ i = j
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
⊢ i = j
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | simp only [if_pos hi, if_neg hj] at hij | case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : i = 0
hj : ¬j = 0
⊢ i = j
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
⊢ i = j | case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hi : i = 0
hj : ¬j = 0
hij : a = b
⊢ i = j
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
⊢ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : i = 0
hj : ¬j = 0
⊢ i = j
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
⊢ i = j
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | exfalso | case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hi : i = 0
hj : ¬j = 0
hij : a = b
⊢ i = j
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
⊢ i = j | case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hi : i = 0
hj : ¬j = 0
hij : a = b
⊢ False
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
⊢ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hi : i = 0
hj : ¬j = 0
hij : a = b
⊢ i = j
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
⊢ i = j
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | exact hab hij | case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hi : i = 0
hj : ¬j = 0
hij : a = b
⊢ False
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
⊢ i = j | case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
⊢ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hi : i = 0
hj : ¬j = 0
hij : a = b
⊢ False
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
⊢ i = j
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | by_cases hj : j = 0 | case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
⊢ i = j | case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
hj : j = 0
⊢ i = j
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
hj : ¬j = 0
⊢ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
⊢ i = j
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | simp only [if_neg hi, if_pos hj] at hij | case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
hj : j = 0
⊢ i = j
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
hj : ¬j = 0
⊢ i = j | case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hi : ¬i = 0
hj : j = 0
hij : b = a
⊢ i = j
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
hj : ¬j = 0
⊢ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
hj : j = 0
⊢ i = j
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
hj : ¬j = 0
⊢ i = j
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | exfalso | case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hi : ¬i = 0
hj : j = 0
hij : b = a
⊢ i = j
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
hj : ¬j = 0
⊢ i = j | case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hi : ¬i = 0
hj : j = 0
hij : b = a
⊢ False
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
hj : ¬j = 0
⊢ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hi : ¬i = 0
hj : j = 0
hij : b = a
⊢ i = j
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
hj : ¬j = 0
⊢ i = j
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | exact hab hij.symm | case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hi : ¬i = 0
hj : j = 0
hij : b = a
⊢ False
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
hj : ¬j = 0
⊢ i = j | case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
hj : ¬j = 0
⊢ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hi : ¬i = 0
hj : j = 0
hij : b = a
⊢ False
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
hj : ¬j = 0
⊢ i = j
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | rw [Or.resolve_left (this i) hi, Or.resolve_left (this j) hj] | case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
hj : ¬j = 0
⊢ i = j | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
a b : α
hab : a ≠ b
i j : Fin 2
hij : (fun i => if i = 0 then a else b) i = (fun i => if i = 0 then a else b) j
hi : ¬i = 0
hj : ¬j = 0
⊢ i = j
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | intro h | case mp
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
⊢ IsMultiplyPretransitive M α 2 → ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d | case mp
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
⊢ ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
⊢ IsMultiplyPretransitive M α 2 → ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | let h' := h.exists_smul_eq | case mp
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
⊢ ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d | case mp
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
h' : ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
⊢ ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | intro a b c d hab hcd | case mp
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
h' : ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d | case mp
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
h' : ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
a b c d : α
hab : a ≠ b
hcd : c ≠ d
⊢ ∃ m, m • a = c ∧ m • b = d | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
h' : ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | obtain ⟨m, hm⟩ := h' (f a b hab) (f c d hcd) | case mp
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
h' : ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
a b c d : α
hab : a ≠ b
hcd : c ≠ d
⊢ ∃ m, m • a = c ∧ m • b = d | case mp.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
h' : ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
a b c d : α
hab : a ≠ b
hcd : c ≠ d
m : M
hm : m • f a b hab = f c d hcd
⊢ ∃ m, m • a = c ∧ m • b = d | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
h' : ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
a b c d : α
hab : a ≠ b
hcd : c ≠ d
⊢ ∃ m, m • a = c ∧ m • b = d
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | rw [← Function.Embedding.ext_iff] at hm | case mp.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
h' : ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
a b c d : α
hab : a ≠ b
hcd : c ≠ d
m : M
hm : m • f a b hab = f c d hcd
⊢ ∃ m, m • a = c ∧ m • b = d | case mp.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
h' : ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
a b c d : α
hab : a ≠ b
hcd : c ≠ d
m : M
hm : ∀ (x : Fin 2), (m • f a b hab) x = (f c d hcd) x
⊢ ∃ m, m • a = c ∧ m • b = d | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
h' : ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
a b c d : α
hab : a ≠ b
hcd : c ≠ d
m : M
hm : m • f a b hab = f c d hcd
⊢ ∃ m, m • a = c ∧ m • b = d
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | use m | case mp.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
h' : ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
a b c d : α
hab : a ≠ b
hcd : c ≠ d
m : M
hm : ∀ (x : Fin 2), (m • f a b hab) x = (f c d hcd) x
⊢ ∃ m, m • a = c ∧ m • b = d | case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
h' : ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
a b c d : α
hab : a ≠ b
hcd : c ≠ d
m : M
hm : ∀ (x : Fin 2), (m • f a b hab) x = (f c d hcd) x
⊢ m • a = c ∧ m • b = d | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
h' : ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
a b c d : α
hab : a ≠ b
hcd : c ≠ d
m : M
hm : ∀ (x : Fin 2), (m • f a b hab) x = (f c d hcd) x
⊢ ∃ m, m • a = c ∧ m • b = d
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | constructor | case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
h' : ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
a b c d : α
hab : a ≠ b
hcd : c ≠ d
m : M
hm : ∀ (x : Fin 2), (m • f a b hab) x = (f c d hcd) x
⊢ m • a = c ∧ m • b = d | case h.left
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
h' : ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
a b c d : α
hab : a ≠ b
hcd : c ≠ d
m : M
hm : ∀ (x : Fin 2), (m • f a b hab) x = (f c d hcd) x
⊢ m • a = c
case h.right
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
h' : ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
a b c d : α
hab : a ≠ b
hcd : c ≠ d
m : M
hm : ∀ (x : Fin 2), (m • f a b hab) x = (f c d hcd) x
⊢ m • b = d | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
h' : ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
a b c d : α
hab : a ≠ b
hcd : c ≠ d
m : M
hm : ∀ (x : Fin 2), (m • f a b hab) x = (f c d hcd) x
⊢ m • a = c ∧ m • b = d
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | simpa only [smul_apply, coeFn_mk, eq_self_iff_true, if_true] using hm 0 | case h.left
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
h' : ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
a b c d : α
hab : a ≠ b
hcd : c ≠ d
m : M
hm : ∀ (x : Fin 2), (m • f a b hab) x = (f c d hcd) x
⊢ m • a = c
case h.right
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
h' : ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
a b c d : α
hab : a ≠ b
hcd : c ≠ d
m : M
hm : ∀ (x : Fin 2), (m • f a b hab) x = (f c d hcd) x
⊢ m • b = d | case h.right
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
h' : ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
a b c d : α
hab : a ≠ b
hcd : c ≠ d
m : M
hm : ∀ (x : Fin 2), (m • f a b hab) x = (f c d hcd) x
⊢ m • b = d | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
h' : ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
a b c d : α
hab : a ≠ b
hcd : c ≠ d
m : M
hm : ∀ (x : Fin 2), (m • f a b hab) x = (f c d hcd) x
⊢ m • a = c
case h.right
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
h' : ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
a b c d : α
hab : a ≠ b
hcd : c ≠ d
m : M
hm : ∀ (x : Fin 2), (m • f a b hab) x = (f c d hcd) x
⊢ m • b = d
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | simpa only [smul_apply, coeFn_mk, eq_self_iff_true, if_true] using hm 1 | case h.right
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
h' : ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
a b c d : α
hab : a ≠ b
hcd : c ≠ d
m : M
hm : ∀ (x : Fin 2), (m • f a b hab) x = (f c d hcd) x
⊢ m • b = d | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : IsMultiplyPretransitive M α 2
h' : ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
a b c d : α
hab : a ≠ b
hcd : c ≠ d
m : M
hm : ∀ (x : Fin 2), (m • f a b hab) x = (f c d hcd) x
⊢ m • b = d
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | intro h | case mpr
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
⊢ (∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d) → IsMultiplyPretransitive M α 2 | case mpr
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
⊢ IsMultiplyPretransitive M α 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
⊢ (∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d) → IsMultiplyPretransitive M α 2
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | apply IsPretransitive.mk | case mpr
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
⊢ IsMultiplyPretransitive M α 2 | case mpr.exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
⊢ ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
⊢ IsMultiplyPretransitive M α 2
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | intro u v | case mpr.exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
⊢ ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y | case mpr.exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
u v : Fin 2 ↪ α
⊢ ∃ g, g • u = v | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
⊢ ∀ (x y : Fin 2 ↪ α), ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | specialize h (u 0) (u 1) (v 0) (v 1) | case mpr.exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
u v : Fin 2 ↪ α
⊢ ∃ g, g • u = v | case mpr.exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
⊢ ∃ g, g • u = v | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
h : ∀ (a b c d : α), a ≠ b → c ≠ d → ∃ m, m • a = c ∧ m • b = d
u v : Fin 2 ↪ α
⊢ ∃ g, g • u = v
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | obtain ⟨m, hm⟩ := h
(by rw [Ne.def, Function.Embedding.apply_eq_iff_eq]; exact zero_ne_one)
(by rw [Ne.def, Function.Embedding.apply_eq_iff_eq]; exact zero_ne_one) | case mpr.exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
⊢ ∃ g, g • u = v | case mpr.exists_smul_eq.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
m : M
hm : m • u 0 = v 0 ∧ m • u 1 = v 1
⊢ ∃ g, g • u = v | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
⊢ ∃ g, g • u = v
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | use m | case mpr.exists_smul_eq.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
m : M
hm : m • u 0 = v 0 ∧ m • u 1 = v 1
⊢ ∃ g, g • u = v | case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
m : M
hm : m • u 0 = v 0 ∧ m • u 1 = v 1
⊢ m • u = v | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.exists_smul_eq.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
m : M
hm : m • u 0 = v 0 ∧ m • u 1 = v 1
⊢ ∃ g, g • u = v
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | ext x | case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
m : M
hm : m • u 0 = v 0 ∧ m • u 1 = v 1
⊢ m • u = v | case h.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
m : M
hm : m • u 0 = v 0 ∧ m • u 1 = v 1
x : Fin 2
⊢ (m • u) x = v x | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
m : M
hm : m • u 0 = v 0 ∧ m • u 1 = v 1
⊢ m • u = v
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | cases' this x with hx hx | case h.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
m : M
hm : m • u 0 = v 0 ∧ m • u 1 = v 1
x : Fin 2
⊢ (m • u) x = v x | case h.h.inl
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
m : M
hm : m • u 0 = v 0 ∧ m • u 1 = v 1
x : Fin 2
hx : x = 0
⊢ (m • u) x = v x
case h.h.inr
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
m : M
hm : m • u 0 = v 0 ∧ m • u 1 = v 1
x : Fin 2
hx : x = 1
⊢ (m • u) x = v x | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
m : M
hm : m • u 0 = v 0 ∧ m • u 1 = v 1
x : Fin 2
⊢ (m • u) x = v x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | simpa only [hx] using hm.left | case h.h.inl
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
m : M
hm : m • u 0 = v 0 ∧ m • u 1 = v 1
x : Fin 2
hx : x = 0
⊢ (m • u) x = v x
case h.h.inr
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
m : M
hm : m • u 0 = v 0 ∧ m • u 1 = v 1
x : Fin 2
hx : x = 1
⊢ (m • u) x = v x | case h.h.inr
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
m : M
hm : m • u 0 = v 0 ∧ m • u 1 = v 1
x : Fin 2
hx : x = 1
⊢ (m • u) x = v x | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.inl
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
m : M
hm : m • u 0 = v 0 ∧ m • u 1 = v 1
x : Fin 2
hx : x = 0
⊢ (m • u) x = v x
case h.h.inr
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
m : M
hm : m • u 0 = v 0 ∧ m • u 1 = v 1
x : Fin 2
hx : x = 1
⊢ (m • u) x = v x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | simpa only [hx] using hm.right | case h.h.inr
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
m : M
hm : m • u 0 = v 0 ∧ m • u 1 = v 1
x : Fin 2
hx : x = 1
⊢ (m • u) x = v x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.inr
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
m : M
hm : m • u 0 = v 0 ∧ m • u 1 = v 1
x : Fin 2
hx : x = 1
⊢ (m • u) x = v x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | rw [Ne.def, Function.Embedding.apply_eq_iff_eq] | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
⊢ u 0 ≠ u 1 | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
⊢ ¬0 = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
⊢ u 0 ≠ u 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | exact zero_ne_one | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
⊢ ¬0 = 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
⊢ ¬0 = 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.is_two_pretransitive_iff | [357, 1] | [403, 35] | rw [Ne.def, Function.Embedding.apply_eq_iff_eq] | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
⊢ v 0 ≠ v 1 | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
⊢ ¬0 = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
this : ∀ (i : Fin 2), i = 0 ∨ i = 1
f : (a b : α) → a ≠ b → Fin 2 ↪ α := fun a b hab => { toFun := fun i => if i = 0 then a else b, inj' := ⋯ }
u v : Fin 2 ↪ α
h : u 0 ≠ u 1 → v 0 ≠ v 1 → ∃ m, m • u 0 = v 0 ∧ m • u 1 = v 1
⊢ v 0 ≠ v 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_higher | [407, 1] | [418, 36] | unfold IsMultiplyPretransitive | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
⊢ IsMultiplyPretransitive M α m | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
⊢ IsPretransitive M (Fin m ↪ α) | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
⊢ IsMultiplyPretransitive M α m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_higher | [407, 1] | [418, 36] | let hn_eq := hn.exists_smul_eq | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
⊢ IsPretransitive M (Fin m ↪ α) | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ IsPretransitive M (Fin m ↪ α) | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
⊢ IsPretransitive M (Fin m ↪ α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_higher | [407, 1] | [418, 36] | apply IsPretransitive.mk | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ IsPretransitive M (Fin m ↪ α) | case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (x y : Fin m ↪ α), ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ IsPretransitive M (Fin m ↪ α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_higher | [407, 1] | [418, 36] | intro x y | case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (x y : Fin m ↪ α), ∃ g, g • x = y | case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin m ↪ α
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (x y : Fin m ↪ α), ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_higher | [407, 1] | [418, 36] | obtain ⟨x', hx'⟩ := may_extend hmn hα x | case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin m ↪ α
⊢ ∃ g, g • x = y | case exists_smul_eq.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin m ↪ α
x' : Fin n ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin m ↪ α
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_higher | [407, 1] | [418, 36] | obtain ⟨y', hy'⟩ := may_extend hmn hα y | case exists_smul_eq.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin m ↪ α
x' : Fin n ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
⊢ ∃ g, g • x = y | case exists_smul_eq.intro.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin m ↪ α
x' : Fin n ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
y' : Fin n ↪ α
hy' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding y' = y
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin m ↪ α
x' : Fin n ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_higher | [407, 1] | [418, 36] | obtain ⟨g, hg⟩ := hn_eq x' y' | case exists_smul_eq.intro.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin m ↪ α
x' : Fin n ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
y' : Fin n ↪ α
hy' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding y' = y
⊢ ∃ g, g • x = y | case exists_smul_eq.intro.intro.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin m ↪ α
x' : Fin n ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
y' : Fin n ↪ α
hy' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding y' = y
g : M
hg : g • x' = y'
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq.intro.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin m ↪ α
x' : Fin n ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
y' : Fin n ↪ α
hy' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding y' = y
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_higher | [407, 1] | [418, 36] | use g | case exists_smul_eq.intro.intro.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin m ↪ α
x' : Fin n ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
y' : Fin n ↪ α
hy' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding y' = y
g : M
hg : g • x' = y'
⊢ ∃ g, g • x = y | case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin m ↪ α
x' : Fin n ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
y' : Fin n ↪ α
hy' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding y' = y
g : M
hg : g • x' = y'
⊢ g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq.intro.intro.intro
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin m ↪ α
x' : Fin n ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
y' : Fin n ↪ α
hy' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding y' = y
g : M
hg : g • x' = y'
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_higher | [407, 1] | [418, 36] | ext | case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin m ↪ α
x' : Fin n ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
y' : Fin n ↪ α
hy' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding y' = y
g : M
hg : g • x' = y'
⊢ g • x = y | case h.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin m ↪ α
x' : Fin n ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
y' : Fin n ↪ α
hy' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding y' = y
g : M
hg : g • x' = y'
x✝ : Fin m
⊢ (g • x) x✝ = y x✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin m ↪ α
x' : Fin n ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
y' : Fin n ↪ α
hy' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding y' = y
g : M
hg : g • x' = y'
⊢ g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_higher | [407, 1] | [418, 36] | rw [← hy', ← hx', ← hg] | case h.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin m ↪ α
x' : Fin n ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
y' : Fin n ↪ α
hy' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding y' = y
g : M
hg : g • x' = y'
x✝ : Fin m
⊢ (g • x) x✝ = y x✝ | case h.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin m ↪ α
x' : Fin n ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
y' : Fin n ↪ α
hy' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding y' = y
g : M
hg : g • x' = y'
x✝ : Fin m
⊢ (g • Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x') x✝ =
(Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding (g • x')) x✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin m ↪ α
x' : Fin n ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
y' : Fin n ↪ α
hy' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding y' = y
g : M
hg : g • x' = y'
x✝ : Fin m
⊢ (g • x) x✝ = y x✝
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_higher | [407, 1] | [418, 36] | rfl | case h.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin m ↪ α
x' : Fin n ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
y' : Fin n ↪ α
hy' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding y' = y
g : M
hg : g • x' = y'
x✝ : Fin m
⊢ (g • Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x') x✝ =
(Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding (g • x')) x✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
hn : IsMultiplyPretransitive M α n
m : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
hn_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : Fin m ↪ α
x' : Fin n ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
y' : Fin n ↪ α
hy' : Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding y' = y
g : M
hg : g • x' = y'
x✝ : Fin m
⊢ (g • Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x') x✝ =
(Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding (g • x')) x✝
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.exists_extends_with_last_eq | [422, 1] | [434, 11] | simpa using hxy | M : Type ?u.67011
α : Type ?u.67014
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
n : ℕ
x✝ : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x y : ↥(SubMulAction.ofStabilizer M a)
hxy : (fun u => id ↑u) x = (fun u => id ↑u) y
⊢ x = y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type ?u.67011
α : Type ?u.67014
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
n : ℕ
x✝ : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
x y : ↥(SubMulAction.ofStabilizer M a)
hxy : (fun u => id ↑u) x = (fun u => id ↑u) y
⊢ x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.exists_extends_with_last_eq | [422, 1] | [434, 11] | intro _ | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
n : ℕ
x : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
⊢ let j := { toFun := fun u => id ↑u, inj' := ⋯ };
∃ x',
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x j ∧
x' { val := n, isLt := ⋯ } = a | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
n : ℕ
x : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
j✝ : ↥(SubMulAction.ofStabilizer M a) ↪ α := { toFun := fun u => id ↑u, inj' := ⋯ }
⊢ ∃ x',
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x j✝ ∧
x' { val := n, isLt := ⋯ } = a | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
n : ℕ
x : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
⊢ let j := { toFun := fun u => id ↑u, inj' := ⋯ };
∃ x',
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x j ∧
x' { val := n, isLt := ⋯ } = a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.exists_extends_with_last_eq | [422, 1] | [434, 11] | refine' may_extend_with (x.trans (subtype _)) a _ | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
n : ℕ
x : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
j✝ : ↥(SubMulAction.ofStabilizer M a) ↪ α := { toFun := fun u => id ↑u, inj' := ⋯ }
⊢ ∃ x',
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x j✝ ∧
x' { val := n, isLt := ⋯ } = a | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
n : ℕ
x : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
j✝ : ↥(SubMulAction.ofStabilizer M a) ↪ α := { toFun := fun u => id ↑u, inj' := ⋯ }
⊢ a ∉ Set.range (Function.Embedding.trans x (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)).toFun | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
n : ℕ
x : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
j✝ : ↥(SubMulAction.ofStabilizer M a) ↪ α := { toFun := fun u => id ↑u, inj' := ⋯ }
⊢ ∃ x',
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x j✝ ∧
x' { val := n, isLt := ⋯ } = a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.exists_extends_with_last_eq | [422, 1] | [434, 11] | rintro ⟨u, hu⟩ | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
n : ℕ
x : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
j✝ : ↥(SubMulAction.ofStabilizer M a) ↪ α := { toFun := fun u => id ↑u, inj' := ⋯ }
⊢ a ∉ Set.range (Function.Embedding.trans x (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)).toFun | case intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
n : ℕ
x : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
j✝ : ↥(SubMulAction.ofStabilizer M a) ↪ α := { toFun := fun u => id ↑u, inj' := ⋯ }
u : Fin n
hu : (Function.Embedding.trans x (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)).toFun u = a
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
n : ℕ
x : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
j✝ : ↥(SubMulAction.ofStabilizer M a) ↪ α := { toFun := fun u => id ↑u, inj' := ⋯ }
⊢ a ∉ Set.range (Function.Embedding.trans x (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)).toFun
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.exists_extends_with_last_eq | [422, 1] | [434, 11] | simp only [toFun_eq_coe, trans_apply, Function.Embedding.coe_subtype] at hu | case intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
n : ℕ
x : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
j✝ : ↥(SubMulAction.ofStabilizer M a) ↪ α := { toFun := fun u => id ↑u, inj' := ⋯ }
u : Fin n
hu : (Function.Embedding.trans x (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)).toFun u = a
⊢ False | case intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
n : ℕ
x : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
j✝ : ↥(SubMulAction.ofStabilizer M a) ↪ α := { toFun := fun u => id ↑u, inj' := ⋯ }
u : Fin n
hu : ↑(x u) = a
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
n : ℕ
x : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
j✝ : ↥(SubMulAction.ofStabilizer M a) ↪ α := { toFun := fun u => id ↑u, inj' := ⋯ }
u : Fin n
hu : (Function.Embedding.trans x (subtype fun x => x ∈ SubMulAction.ofStabilizer M a)).toFun u = a
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.exists_extends_with_last_eq | [422, 1] | [434, 11] | apply SubMulAction.neq_of_mem_ofStabilizer M a | case intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
n : ℕ
x : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
j✝ : ↥(SubMulAction.ofStabilizer M a) ↪ α := { toFun := fun u => id ↑u, inj' := ⋯ }
u : Fin n
hu : ↑(x u) = a
⊢ False | case intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
n : ℕ
x : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
j✝ : ↥(SubMulAction.ofStabilizer M a) ↪ α := { toFun := fun u => id ↑u, inj' := ⋯ }
u : Fin n
hu : ↑(x u) = a
⊢ ↑?m.69556 = a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
n : ℕ
x : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
j✝ : ↥(SubMulAction.ofStabilizer M a) ↪ α := { toFun := fun u => id ↑u, inj' := ⋯ }
u : Fin n
hu : ↑(x u) = a
⊢ ↥(SubMulAction.ofStabilizer M a) | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
n : ℕ
x : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
j✝ : ↥(SubMulAction.ofStabilizer M a) ↪ α := { toFun := fun u => id ↑u, inj' := ⋯ }
u : Fin n
hu : ↑(x u) = a
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.exists_extends_with_last_eq | [422, 1] | [434, 11] | exact hu | case intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
n : ℕ
x : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
j✝ : ↥(SubMulAction.ofStabilizer M a) ↪ α := { toFun := fun u => id ↑u, inj' := ⋯ }
u : Fin n
hu : ↑(x u) = a
⊢ ↑?m.69556 = a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
n : ℕ
x : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
j✝ : ↥(SubMulAction.ofStabilizer M a) ↪ α := { toFun := fun u => id ↑u, inj' := ⋯ }
u : Fin n
hu : ↑(x u) = a
⊢ ↥(SubMulAction.ofStabilizer M a) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
n : ℕ
x : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
j✝ : ↥(SubMulAction.ofStabilizer M a) ↪ α := { toFun := fun u => id ↑u, inj' := ⋯ }
u : Fin n
hu : ↑(x u) = a
⊢ ↑?m.69556 = a
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
n : ℕ
x : Fin n ↪ ↥(SubMulAction.ofStabilizer M a)
j✝ : ↥(SubMulAction.ofStabilizer M a) ↪ α := { toFun := fun u => id ↑u, inj' := ⋯ }
u : Fin n
hu : ↑(x u) = a
⊢ ↥(SubMulAction.ofStabilizer M a)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.exists_smul_of_last_eq | [436, 1] | [460, 14] | let hα'eq := hα'.exists_smul_eq | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
⊢ ∃ g x1,
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a) ∧
g • x (Fin.last n) = a | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∃ g x1,
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a) ∧
g • x (Fin.last n) = a | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
⊢ ∃ g x1,
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a) ∧
g • x (Fin.last n) = a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.exists_smul_of_last_eq | [436, 1] | [460, 14] | obtain ⟨g, hgx⟩ := hα'eq (x (Fin.last n)) a | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∃ g x1,
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a) ∧
g • x (Fin.last n) = a | case intro
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
g : M
hgx : g • x (Fin.last n) = a
⊢ ∃ g x1,
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a) ∧
g • x (Fin.last n) = a | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
hα' : IsPretransitive M α
n : ℕ
a : α
x : Fin (succ n) ↪ α
hα'eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∃ g x1,
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (g • x) =
Function.Embedding.trans x1 (subtype fun x => x ∈ SubMulAction.ofStabilizer M a) ∧
g • x (Fin.last n) = a
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.