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/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | convert Nat.prime_three | case inr.intro.hmt.h.refine'_4.hp
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
this :
IsPretransitive ↥(fixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
↥(SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
⊢ Nat.Prime (Fintype.card ↥(SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)) | case h.e'_1
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
this :
IsPretransitive ↥(fixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
↥(SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
⊢ Fintype.card ↥(SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ) = 3 | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.hmt.h.refine'_4.hp
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
this :
IsPretransitive ↥(fixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
↥(SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
⊢ Nat.Prime (Fintype.card ↥(SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ))
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | rw [Fintype.card_subtype, ← Equiv.Perm.IsThreeCycle.card_support h3g] | case h.e'_1
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
this :
IsPretransitive ↥(fixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
↥(SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
⊢ Fintype.card ↥(SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ) = 3 | case h.e'_1
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
this :
IsPretransitive ↥(fixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
↥(SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
⊢ (Finset.filter (fun x => x ∈ SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ) Finset.univ).card =
(Equiv.Perm.support g).card | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_1
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
this :
IsPretransitive ↥(fixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
↥(SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
⊢ Fintype.card ↥(SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ) = 3
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | apply congr_arg | case h.e'_1
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
this :
IsPretransitive ↥(fixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
↥(SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
⊢ (Finset.filter (fun x => x ∈ SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ) Finset.univ).card =
(Equiv.Perm.support g).card | case h.e'_1.h
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
this :
IsPretransitive ↥(fixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
↥(SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
⊢ Finset.filter (fun x => x ∈ SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ) Finset.univ =
Equiv.Perm.support g | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_1
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
this :
IsPretransitive ↥(fixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
↥(SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
⊢ (Finset.filter (fun x => x ∈ SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ) Finset.univ).card =
(Equiv.Perm.support g).card
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | ext x | case h.e'_1.h
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
this :
IsPretransitive ↥(fixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
↥(SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
⊢ Finset.filter (fun x => x ∈ SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ) Finset.univ =
Equiv.Perm.support g | case h.e'_1.h.a
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
this :
IsPretransitive ↥(fixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
↥(SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
x : α
⊢ x ∈ Finset.filter (fun x => x ∈ SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ) Finset.univ ↔
x ∈ Equiv.Perm.support g | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_1.h
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
this :
IsPretransitive ↥(fixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
↥(SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
⊢ Finset.filter (fun x => x ∈ SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ) Finset.univ =
Equiv.Perm.support g
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | simp [SubMulAction.mem_ofFixingSubgroup_iff] | case h.e'_1.h.a
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
this :
IsPretransitive ↥(fixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
↥(SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
x : α
⊢ x ∈ Finset.filter (fun x => x ∈ SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ) Finset.univ ↔
x ∈ Equiv.Perm.support g | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_1.h.a
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
this :
IsPretransitive ↥(fixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
↥(SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ)
x : α
⊢ x ∈ Finset.filter (fun x => x ∈ SubMulAction.ofFixingSubgroup (↥G) (↑(Equiv.Perm.support g))ᶜ) Finset.univ ↔
x ∈ Equiv.Perm.support g
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | rw [Nat.lt_succ_iff] at hα4 | case inl
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α < 4
⊢ alternatingGroup α ≤ G | case inl
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ alternatingGroup α ≤ G | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α < 4
⊢ alternatingGroup α ≤ G
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | apply large_subgroup_of_perm_contains_alternating | case inl
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ alternatingGroup α ≤ G | case inl.hG
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ Fintype.card (Equiv.Perm α) ≤ 2 * Fintype.card ↥G | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ alternatingGroup α ≤ G
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | rw [Fintype.card_perm] | case inl.hG
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ Fintype.card (Equiv.Perm α) ≤ 2 * Fintype.card ↥G | case inl.hG
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ Nat.factorial (Fintype.card α) ≤ 2 * Fintype.card ↥G | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.hG
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ Fintype.card (Equiv.Perm α) ≤ 2 * Fintype.card ↥G
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | apply le_trans (Nat.factorial_le hα4) | case inl.hG
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ Nat.factorial (Fintype.card α) ≤ 2 * Fintype.card ↥G | case inl.hG
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ Nat.factorial 3 ≤ 2 * Fintype.card ↥G | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.hG
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ Nat.factorial (Fintype.card α) ≤ 2 * Fintype.card ↥G
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | change 2 * 3 ≤ _ | case inl.hG
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ Nat.factorial 3 ≤ 2 * Fintype.card ↥G | case inl.hG
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ 2 * 3 ≤ 2 * Fintype.card ↥G | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.hG
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ Nat.factorial 3 ≤ 2 * Fintype.card ↥G
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | simp only [mul_le_mul_left, Nat.succ_pos'] | case inl.hG
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ 2 * 3 ≤ 2 * Fintype.card ↥G | case inl.hG
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ 3 ≤ Fintype.card ↥G | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.hG
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ 2 * 3 ≤ 2 * Fintype.card ↥G
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | apply Nat.le_of_dvd Fintype.card_pos | case inl.hG
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ 3 ≤ Fintype.card ↥G | case inl.hG
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ 3 ∣ Fintype.card ↥G | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.hG
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ 3 ≤ Fintype.card ↥G
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | suffices 3 = orderOf (⟨g, hg⟩ : G) by
rw [this]
exact orderOf_dvd_card | case inl.hG
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ 3 ∣ Fintype.card ↥G | case inl.hG
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ 3 = orderOf { val := g, property := hg } | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.hG
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ 3 ∣ Fintype.card ↥G
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | rw [← Equiv.Perm.IsThreeCycle.orderOf h3g] | case inl.hG
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ 3 = orderOf { val := g, property := hg } | case inl.hG
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ orderOf g = orderOf { val := g, property := hg } | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.hG
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ 3 = orderOf { val := g, property := hg }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | convert orderOf_submonoid _ | case inl.hG
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ orderOf g = orderOf { val := g, property := hg } | case h.e'_2.h.e'_3
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ g = ↑{ val := g, property := hg } | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.hG
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ orderOf g = orderOf { val := g, property := hg }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | rfl | case h.e'_2.h.e'_3
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ g = ↑{ val := g, property := hg } | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_2.h.e'_3
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
⊢ g = ↑{ val := g, property := hg }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | rw [this] | α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
this : 3 = orderOf { val := g, property := hg }
⊢ 3 ∣ Fintype.card ↥G | α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
this : 3 = orderOf { val := g, property := hg }
⊢ orderOf { val := g, property := hg } ∣ Fintype.card ↥G | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
this : 3 = orderOf { val := g, property := hg }
⊢ 3 ∣ Fintype.card ↥G
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | exact orderOf_dvd_card | α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
this : 3 = orderOf { val := g, property := hg }
⊢ orderOf { val := g, property := hg } ∣ Fintype.card ↥G | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≤ 3
this : 3 = orderOf { val := g, property := hg }
⊢ orderOf { val := g, property := hg } ∣ Fintype.card ↥G
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | simp [hn, add_comm 1] | α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
⊢ Fintype.card α - 2 = 1 + Nat.succ n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
⊢ Fintype.card α - 2 = 1 + Nat.succ n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | apply Nat.add_left_cancel | case inr.intro.hmt.h.refine'_2
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
⊢ Set.ncard (↑(Equiv.Perm.support g))ᶜ = Nat.succ n | case inr.intro.hmt.h.refine'_2.a
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
⊢ ?inr.intro.hmt.h.refine'_2.n + Set.ncard (↑(Equiv.Perm.support g))ᶜ = ?inr.intro.hmt.h.refine'_2.n + Nat.succ n
case inr.intro.hmt.h.refine'_2.n
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
⊢ ℕ | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.hmt.h.refine'_2
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
⊢ Set.ncard (↑(Equiv.Perm.support g))ᶜ = Nat.succ n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | rw [Set.ncard_add_ncard_compl, Set.ncard_coe_Finset,
Equiv.Perm.IsThreeCycle.card_support h3g,
add_comm, Nat.card_eq_fintype_card, hn] | case inr.intro.hmt.h.refine'_2.a
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
⊢ ?inr.intro.hmt.h.refine'_2.n + Set.ncard (↑(Equiv.Perm.support g))ᶜ = ?inr.intro.hmt.h.refine'_2.n + Nat.succ n
case inr.intro.hmt.h.refine'_2.n
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
⊢ ℕ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.hmt.h.refine'_2.a
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
⊢ ?inr.intro.hmt.h.refine'_2.n + Set.ncard (↑(Equiv.Perm.support g))ᶜ = ?inr.intro.hmt.h.refine'_2.n + Nat.succ n
case inr.intro.hmt.h.refine'_2.n
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
⊢ ℕ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | rw [hn, Nat.succ_eq_add_one, add_comm, add_assoc] | case inr.intro.hmt.h.refine'_3
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
⊢ 1 + Nat.succ n < Fintype.card α | case inr.intro.hmt.h.refine'_3
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
⊢ n + (1 + 1) < n + 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.hmt.h.refine'_3
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
⊢ 1 + Nat.succ n < Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | simp only [add_lt_add_iff_left] | case inr.intro.hmt.h.refine'_3
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
⊢ n + (1 + 1) < n + 4 | case inr.intro.hmt.h.refine'_3
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
⊢ 1 + 1 < 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.hmt.h.refine'_3
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
⊢ n + (1 + 1) < n + 4
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | norm_num | case inr.intro.hmt.h.refine'_3
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
⊢ 1 + 1 < 4 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.hmt.h.refine'_3
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
⊢ 1 + 1 < 4
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | apply isPretransitive_of_cycle hg | α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
⊢ IsPretransitive ?m.354282 ?m.354283 | α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
⊢ Equiv.Perm.IsCycle g | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
⊢ IsPretransitive ?m.354282 ?m.354283
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Jordan.lean | jordan_three_cycle | [883, 1] | [930, 47] | exact Equiv.Perm.IsThreeCycle.isCycle h3g | α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
⊢ Equiv.Perm.IsCycle g | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : Fintype α
G : Subgroup (Equiv.Perm α)
inst✝ : DecidableEq α
hG : IsPreprimitive (↥G) α
g : Equiv.Perm α
h3g : Equiv.Perm.IsThreeCycle g
hg : g ∈ G
hα4 : Fintype.card α ≥ 4
n : ℕ
hn : Fintype.card α = n + 4
hn' : Fintype.card α - 2 = 1 + Nat.succ n
⊢ Equiv.Perm.IsCycle g
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | gimme_some | [27, 1] | [33, 53] | suffices Nonempty (ULift (Fin m) ↪ α) by
obtain ⟨x'⟩ := this;
use Equiv.ulift.symm.toEmbedding.trans x'
apply Function.Embedding.injective | α : Type u_1
m : ℕ
hα : ↑m ≤ PartENat.card α
⊢ Nonempty (Fin m ↪ α) | α : Type u_1
m : ℕ
hα : ↑m ≤ PartENat.card α
⊢ Nonempty (ULift.{?u.347, 0} (Fin m) ↪ α) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
m : ℕ
hα : ↑m ≤ PartENat.card α
⊢ Nonempty (Fin m ↪ α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | gimme_some | [27, 1] | [33, 53] | rw [← Cardinal.le_def, Cardinal.mk_fintype, Fintype.card_ulift, Fintype.card_fin] | α : Type u_1
m : ℕ
hα : ↑m ≤ PartENat.card α
⊢ Nonempty (ULift.{?u.347, 0} (Fin m) ↪ α) | α : Type u_1
m : ℕ
hα : ↑m ≤ PartENat.card α
⊢ ↑m ≤ Cardinal.mk α | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
m : ℕ
hα : ↑m ≤ PartENat.card α
⊢ Nonempty (ULift.{?u.347, 0} (Fin m) ↪ α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | gimme_some | [27, 1] | [33, 53] | exact Iff.mp Cardinal.natCast_le_toPartENat_iff hα | α : Type u_1
m : ℕ
hα : ↑m ≤ PartENat.card α
⊢ ↑m ≤ Cardinal.mk α | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
m : ℕ
hα : ↑m ≤ PartENat.card α
⊢ ↑m ≤ Cardinal.mk α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | gimme_some | [27, 1] | [33, 53] | obtain ⟨x'⟩ := this | α : Type u_1
m : ℕ
hα : ↑m ≤ PartENat.card α
this : Nonempty (ULift.{?u.347, 0} (Fin m) ↪ α)
⊢ Nonempty (Fin m ↪ α) | case intro
α : Type u_1
m : ℕ
hα : ↑m ≤ PartENat.card α
x' : ULift.{?u.347, 0} (Fin m) ↪ α
⊢ Nonempty (Fin m ↪ α) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
m : ℕ
hα : ↑m ≤ PartENat.card α
this : Nonempty (ULift.{?u.347, 0} (Fin m) ↪ α)
⊢ Nonempty (Fin m ↪ α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | gimme_some | [27, 1] | [33, 53] | use Equiv.ulift.symm.toEmbedding.trans x' | case intro
α : Type u_1
m : ℕ
hα : ↑m ≤ PartENat.card α
x' : ULift.{?u.347, 0} (Fin m) ↪ α
⊢ Nonempty (Fin m ↪ α) | case inj'
α : Type u_1
m : ℕ
hα : ↑m ≤ PartENat.card α
x' : ULift.{?u.347, 0} (Fin m) ↪ α
⊢ Function.Injective ⇑(Function.Embedding.trans (Equiv.toEmbedding Equiv.ulift.symm) x') | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
α : Type u_1
m : ℕ
hα : ↑m ≤ PartENat.card α
x' : ULift.{?u.347, 0} (Fin m) ↪ α
⊢ Nonempty (Fin m ↪ α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | gimme_some | [27, 1] | [33, 53] | apply Function.Embedding.injective | case inj'
α : Type u_1
m : ℕ
hα : ↑m ≤ PartENat.card α
x' : ULift.{?u.347, 0} (Fin m) ↪ α
⊢ Function.Injective ⇑(Function.Embedding.trans (Equiv.toEmbedding Equiv.ulift.symm) x') | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inj'
α : Type u_1
m : ℕ
hα : ↑m ≤ PartENat.card α
x' : ULift.{?u.347, 0} (Fin m) ↪ α
⊢ Function.Injective ⇑(Function.Embedding.trans (Equiv.toEmbedding Equiv.ulift.symm) x')
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | gimme_some_equiv | [36, 1] | [37, 50] | exact ⟨(Fintype.equivFinOfCardEq hα.symm).symm⟩ | α : Type u_1
m : ℕ
inst✝ : Fintype α
hα : m = Fintype.card α
⊢ Nonempty (Fin m ≃ α) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
m : ℕ
inst✝ : Fintype α
hα : m = Fintype.card α
⊢ Nonempty (Fin m ≃ α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | equiv_fin_of_partENat_card_eq | [42, 1] | [50, 12] | cases' fintypeOrInfinite α with h h | α : Type u_1
m : ℕ
hα : PartENat.card α = ↑m
⊢ Nonempty (Fin m ≃ α) | case inl
α : Type u_1
m : ℕ
hα : PartENat.card α = ↑m
h : Fintype α
⊢ Nonempty (Fin m ≃ α)
case inr
α : Type u_1
m : ℕ
hα : PartENat.card α = ↑m
h : Infinite α
⊢ Nonempty (Fin m ≃ α) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
m : ℕ
hα : PartENat.card α = ↑m
⊢ Nonempty (Fin m ≃ α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | equiv_fin_of_partENat_card_eq | [42, 1] | [50, 12] | simp only [PartENat.card_eq_coe_fintype_card, PartENat.natCast_inj] at hα | case inl
α : Type u_1
m : ℕ
hα : PartENat.card α = ↑m
h : Fintype α
⊢ Nonempty (Fin m ≃ α) | case inl
α : Type u_1
m : ℕ
h : Fintype α
hα : Fintype.card α = m
⊢ Nonempty (Fin m ≃ α) | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
α : Type u_1
m : ℕ
hα : PartENat.card α = ↑m
h : Fintype α
⊢ Nonempty (Fin m ≃ α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | equiv_fin_of_partENat_card_eq | [42, 1] | [50, 12] | exact ⟨(Fintype.equivFinOfCardEq hα).symm⟩ | case inl
α : Type u_1
m : ℕ
h : Fintype α
hα : Fintype.card α = m
⊢ Nonempty (Fin m ≃ α) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
α : Type u_1
m : ℕ
h : Fintype α
hα : Fintype.card α = m
⊢ Nonempty (Fin m ≃ α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | equiv_fin_of_partENat_card_eq | [42, 1] | [50, 12] | rw [PartENat.card_eq_top_of_infinite] at hα | case inr
α : Type u_1
m : ℕ
hα : PartENat.card α = ↑m
h : Infinite α
⊢ Nonempty (Fin m ≃ α) | case inr
α : Type u_1
m : ℕ
hα : ⊤ = ↑m
h : Infinite α
⊢ Nonempty (Fin m ≃ α) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
α : Type u_1
m : ℕ
hα : PartENat.card α = ↑m
h : Infinite α
⊢ Nonempty (Fin m ≃ α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | equiv_fin_of_partENat_card_eq | [42, 1] | [50, 12] | exfalso | case inr
α : Type u_1
m : ℕ
hα : ⊤ = ↑m
h : Infinite α
⊢ Nonempty (Fin m ≃ α) | case inr
α : Type u_1
m : ℕ
hα : ⊤ = ↑m
h : Infinite α
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
α : Type u_1
m : ℕ
hα : ⊤ = ↑m
h : Infinite α
⊢ Nonempty (Fin m ≃ α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | equiv_fin_of_partENat_card_eq | [42, 1] | [50, 12] | apply PartENat.natCast_ne_top m | case inr
α : Type u_1
m : ℕ
hα : ⊤ = ↑m
h : Infinite α
⊢ False | case inr
α : Type u_1
m : ℕ
hα : ⊤ = ↑m
h : Infinite α
⊢ ↑m = ⊤ | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
α : Type u_1
m : ℕ
hα : ⊤ = ↑m
h : Infinite α
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | equiv_fin_of_partENat_card_eq | [42, 1] | [50, 12] | rw [hα] | case inr
α : Type u_1
m : ℕ
hα : ⊤ = ↑m
h : Infinite α
⊢ ↑m = ⊤ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
α : Type u_1
m : ℕ
hα : ⊤ = ↑m
h : Infinite α
⊢ ↑m = ⊤
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | gimme_another | [53, 1] | [66, 42] | rw [← Set.ne_univ_iff_exists_not_mem] | α : Type u_1
m : ℕ
f : Fin m → α
hα : ↑m < PartENat.card α
⊢ ∃ a, a ∉ Set.range f | α : Type u_1
m : ℕ
f : Fin m → α
hα : ↑m < PartENat.card α
⊢ Set.range f ≠ Set.univ | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
m : ℕ
f : Fin m → α
hα : ↑m < PartENat.card α
⊢ ∃ a, a ∉ Set.range f
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | gimme_another | [53, 1] | [66, 42] | intro h | α : Type u_1
m : ℕ
f : Fin m → α
hα : ↑m < PartENat.card α
⊢ Set.range f ≠ Set.univ | α : Type u_1
m : ℕ
f : Fin m → α
hα : ↑m < PartENat.card α
h : Set.range f = Set.univ
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
m : ℕ
f : Fin m → α
hα : ↑m < PartENat.card α
⊢ Set.range f ≠ Set.univ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | gimme_another | [53, 1] | [66, 42] | rw [← not_le] at hα | α : Type u_1
m : ℕ
f : Fin m → α
hα : ↑m < PartENat.card α
h : Set.range f = Set.univ
⊢ False | α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
m : ℕ
f : Fin m → α
hα : ↑m < PartENat.card α
h : Set.range f = Set.univ
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | gimme_another | [53, 1] | [66, 42] | apply hα | α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ False | α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ PartENat.card α ≤ ↑m | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | gimme_another | [53, 1] | [66, 42] | rw [← PartENat.card_congr (Equiv.Set.univ α), ← h] | α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ PartENat.card α ≤ ↑m | α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ PartENat.card ↑(Set.range f) ≤ ↑m | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ PartENat.card α ≤ ↑m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | gimme_another | [53, 1] | [66, 42] | unfold PartENat.card | α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ PartENat.card ↑(Set.range f) ≤ ↑m | α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ Cardinal.toPartENat (Cardinal.mk ↑(Set.range f)) ≤ ↑m | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ PartENat.card ↑(Set.range f) ≤ ↑m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | gimme_another | [53, 1] | [66, 42] | rw [Cardinal.toPartENat_le_natCast_iff] | α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ Cardinal.toPartENat (Cardinal.mk ↑(Set.range f)) ≤ ↑m | α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ Cardinal.mk ↑(Set.range f) ≤ ↑m | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ Cardinal.toPartENat (Cardinal.mk ↑(Set.range f)) ≤ ↑m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | gimme_another | [53, 1] | [66, 42] | convert Cardinal.mk_range_le | α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ Cardinal.mk ↑(Set.range f) ≤ ↑m | case h.e'_3.h.e'_1.h.e'_2
α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ Set.range f = Set.range ?convert_3
case convert_3
α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ ULift.{u_1, 0} (Fin m) → α | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ Cardinal.mk ↑(Set.range f) ≤ ↑m
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | gimme_another | [53, 1] | [66, 42] | swap | case h.e'_3.h.e'_1.h.e'_2
α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ Set.range f = Set.range ?convert_3
case convert_3
α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ ULift.{u_1, 0} (Fin m) → α | case convert_3
α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ ULift.{u_1, 0} (Fin m) → α
case h.e'_3.h.e'_1.h.e'_2
α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ Set.range f = Set.range ?convert_3 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_1.h.e'_2
α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ Set.range f = Set.range ?convert_3
case convert_3
α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ ULift.{u_1, 0} (Fin m) → α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | gimme_another | [53, 1] | [66, 42] | exact fun n ↦ f (n.down) | case convert_3
α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ ULift.{u_1, 0} (Fin m) → α
case h.e'_3.h.e'_1.h.e'_2
α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ Set.range f = Set.range ?convert_3 | case h.e'_3.h.e'_1.h.e'_2
α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ Set.range f = Set.range fun n => f n.down | Please generate a tactic in lean4 to solve the state.
STATE:
case convert_3
α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ ULift.{u_1, 0} (Fin m) → α
case h.e'_3.h.e'_1.h.e'_2
α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ Set.range f = Set.range ?convert_3
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | gimme_another | [53, 1] | [66, 42] | ext a | case h.e'_3.h.e'_1.h.e'_2
α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ Set.range f = Set.range fun n => f n.down | case h.e'_3.h.e'_1.h.e'_2.h
α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
a : α
⊢ a ∈ Set.range f ↔ a ∈ Set.range fun n => f n.down | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_1.h.e'_2
α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
⊢ Set.range f = Set.range fun n => f n.down
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | gimme_another | [53, 1] | [66, 42] | simp only [Set.mem_range, ULift.exists] | case h.e'_3.h.e'_1.h.e'_2.h
α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
a : α
⊢ a ∈ Set.range f ↔ a ∈ Set.range fun n => f n.down | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_1.h.e'_2.h
α : Type u_1
m : ℕ
f : Fin m → α
hα : ¬PartENat.card α ≤ ↑m
h : Set.range f = Set.univ
a : α
⊢ a ∈ Set.range f ↔ a ∈ Set.range fun n => f n.down
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | let p := fun i : Fin n.succ => i.val < n | α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = x ∧ x' { val := n, isLt := ⋯ } = a | α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = x ∧ x' { val := n, isLt := ⋯ } = a | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = x ∧ x' { val := n, isLt := ⋯ } = a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | let f : {i : Fin n.succ | i.val < n} → α := fun i => x.toFun (Fin.castLT i.val i.prop) | α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = x ∧ x' { val := n, isLt := ⋯ } = a | α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = x ∧ x' { val := n, isLt := ⋯ } = a | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = x ∧ x' { val := n, isLt := ⋯ } = a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | let f' : {i : Fin n.succ | ¬p i} ↪ α := {
toFun := fun ⟨_, _⟩ => a
inj' := by
rintro ⟨i, hi⟩ ⟨j, hj⟩ _
simp only [Subtype.mk_eq_mk, Fin.ext_iff]
rw [Nat.eq_of_lt_succ_of_not_lt i.prop hi, Nat.eq_of_lt_succ_of_not_lt j.prop hj] } | α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = x ∧ x' { val := n, isLt := ⋯ } = a | α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = x ∧ x' { val := n, isLt := ⋯ } = a | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = x ∧ x' { val := n, isLt := ⋯ } = a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | constructor | case h
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
⊢ Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else f' { val := i, property := hi },
inj' := ⋯ } =
x ∧
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else f' { val := i, property := hi },
inj' := ⋯ }
{ val := n, isLt := ⋯ } =
a | case h.left
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
⊢ Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else f' { val := i, property := hi },
inj' := ⋯ } =
x
case h.right
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
⊢ { toFun := fun i => if hi : p i then f { val := i, property := hi } else f' { val := i, property := hi }, inj' := ⋯ }
{ val := n, isLt := ⋯ } =
a | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
⊢ Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else f' { val := i, property := hi },
inj' := ⋯ } =
x ∧
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else f' { val := i, property := hi },
inj' := ⋯ }
{ val := n, isLt := ⋯ } =
a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | rintro ⟨i, hi⟩ ⟨j, hj⟩ _ | α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
⊢ Function.Injective fun x =>
match x with
| { val := val, property := property } => a | case mk.mk
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
i : Fin (succ n)
hi : i ∈ {i | ¬p i}
j : Fin (succ n)
hj : j ∈ {i | ¬p i}
a✝ :
(fun x =>
match x with
| { val := val, property := property } => a)
{ val := i, property := hi } =
(fun x =>
match x with
| { val := val, property := property } => a)
{ val := j, property := hj }
⊢ { val := i, property := hi } = { val := j, property := hj } | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
⊢ Function.Injective fun x =>
match x with
| { val := val, property := property } => a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | simp only [Subtype.mk_eq_mk, Fin.ext_iff] | case mk.mk
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
i : Fin (succ n)
hi : i ∈ {i | ¬p i}
j : Fin (succ n)
hj : j ∈ {i | ¬p i}
a✝ :
(fun x =>
match x with
| { val := val, property := property } => a)
{ val := i, property := hi } =
(fun x =>
match x with
| { val := val, property := property } => a)
{ val := j, property := hj }
⊢ { val := i, property := hi } = { val := j, property := hj } | case mk.mk
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
i : Fin (succ n)
hi : i ∈ {i | ¬p i}
j : Fin (succ n)
hj : j ∈ {i | ¬p i}
a✝ :
(fun x =>
match x with
| { val := val, property := property } => a)
{ val := i, property := hi } =
(fun x =>
match x with
| { val := val, property := property } => a)
{ val := j, property := hj }
⊢ ↑i = ↑j | Please generate a tactic in lean4 to solve the state.
STATE:
case mk.mk
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
i : Fin (succ n)
hi : i ∈ {i | ¬p i}
j : Fin (succ n)
hj : j ∈ {i | ¬p i}
a✝ :
(fun x =>
match x with
| { val := val, property := property } => a)
{ val := i, property := hi } =
(fun x =>
match x with
| { val := val, property := property } => a)
{ val := j, property := hj }
⊢ { val := i, property := hi } = { val := j, property := hj }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | rw [Nat.eq_of_lt_succ_of_not_lt i.prop hi, Nat.eq_of_lt_succ_of_not_lt j.prop hj] | case mk.mk
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
i : Fin (succ n)
hi : i ∈ {i | ¬p i}
j : Fin (succ n)
hj : j ∈ {i | ¬p i}
a✝ :
(fun x =>
match x with
| { val := val, property := property } => a)
{ val := i, property := hi } =
(fun x =>
match x with
| { val := val, property := property } => a)
{ val := j, property := hj }
⊢ ↑i = ↑j | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mk.mk
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
i : Fin (succ n)
hi : i ∈ {i | ¬p i}
j : Fin (succ n)
hj : j ∈ {i | ¬p i}
a✝ :
(fun x =>
match x with
| { val := val, property := property } => a)
{ val := i, property := hi } =
(fun x =>
match x with
| { val := val, property := property } => a)
{ val := j, property := hj }
⊢ ↑i = ↑j
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | apply Function.Injective.dite p | α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
⊢ Function.Injective fun i => if hi : p i then f { val := i, property := hi } else f' { val := i, property := hi } | case hf
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
⊢ Function.Injective f
case hf'
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
⊢ Function.Injective ⇑f'
case im_disj
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
⊢ ∀ {x x' : Fin (succ n)} {hx : p x} {hx' : ¬p x'}, f { val := x, property := hx } ≠ f' { val := x', property := hx' } | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
⊢ Function.Injective fun i => if hi : p i then f { val := i, property := hi } else f' { val := i, property := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | rintro ⟨i, hi⟩ ⟨j, hj⟩ hij | case hf
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
⊢ Function.Injective f | case hf.mk.mk
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ { val := i, property := hi } = { val := j, property := hj } | Please generate a tactic in lean4 to solve the state.
STATE:
case hf
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
⊢ Function.Injective f
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | rw [Subtype.mk_eq_mk] | case hf.mk.mk
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ { val := i, property := hi } = { val := j, property := hj } | case hf.mk.mk
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
case hf.mk.mk
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ { val := i, property := hi } = { val := j, property := hj }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | apply Fin.ext | case hf.mk.mk
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ i = j | case hf.mk.mk.h
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ↑i = ↑j | Please generate a tactic in lean4 to solve the state.
STATE:
case hf.mk.mk
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ i = j
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | rw [← Fin.coe_castLT i _] | case hf.mk.mk.h
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ↑i = ↑j | case hf.mk.mk.h
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ↑(Fin.castLT i ?m.8352) = ↑j
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ℕ
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ↑i < ?m.8351 | Please generate a tactic in lean4 to solve the state.
STATE:
case hf.mk.mk.h
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ↑i = ↑j
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | rw [← Fin.coe_castLT j _] | case hf.mk.mk.h
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ↑(Fin.castLT i ?m.8352) = ↑j
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ℕ
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ↑i < ?m.8351 | case hf.mk.mk.h
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ↑(Fin.castLT i ?m.8352) = ↑(Fin.castLT j ?m.8372)
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ℕ
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ↑j < ?m.8371
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ℕ
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ↑i < ?m.8351
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ℕ
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ↑i < ?m.8351 | Please generate a tactic in lean4 to solve the state.
STATE:
case hf.mk.mk.h
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ↑(Fin.castLT i ?m.8352) = ↑j
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ℕ
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ↑i < ?m.8351
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | rw [x.inj' hij] | case hf.mk.mk.h
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ↑(Fin.castLT i ?m.8352) = ↑(Fin.castLT j ?m.8372)
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ℕ
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ↑j < ?m.8371
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ℕ
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ↑i < ?m.8351
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ℕ
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ↑i < ?m.8351 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case hf.mk.mk.h
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ↑(Fin.castLT i ?m.8352) = ↑(Fin.castLT j ?m.8372)
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ℕ
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ↑j < ?m.8371
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ℕ
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ↑i < ?m.8351
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ℕ
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : Fin (succ n)
hi : p i
j : Fin (succ n)
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ ↑i < ?m.8351
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | exact Function.Embedding.injective f' | case hf'
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
⊢ Function.Injective ⇑f' | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case hf'
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
⊢ Function.Injective ⇑f'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | intros | case im_disj
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
⊢ ∀ {x x' : Fin (succ n)} {hx : p x} {hx' : ¬p x'}, f { val := x, property := hx } ≠ f' { val := x', property := hx' } | case im_disj
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
x✝ x'✝ : Fin (succ n)
hx✝ : p x✝
hx'✝ : ¬p x'✝
⊢ f { val := x✝, property := hx✝ } ≠ f' { val := x'✝, property := hx'✝ } | Please generate a tactic in lean4 to solve the state.
STATE:
case im_disj
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
⊢ ∀ {x x' : Fin (succ n)} {hx : p x} {hx' : ¬p x'}, f { val := x, property := hx } ≠ f' { val := x', property := hx' }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | simp only [Set.coe_setOf, Set.mem_setOf_eq, toFun_eq_coe, coeFn_mk, ne_eq] | case im_disj
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
x✝ x'✝ : Fin (succ n)
hx✝ : p x✝
hx'✝ : ¬p x'✝
⊢ f { val := x✝, property := hx✝ } ≠ f' { val := x'✝, property := hx'✝ } | case im_disj
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
x✝ x'✝ : Fin (succ n)
hx✝ : p x✝
hx'✝ : ¬p x'✝
⊢ ¬f { val := x✝, property := hx✝ } = f' { val := x'✝, property := hx'✝ } | Please generate a tactic in lean4 to solve the state.
STATE:
case im_disj
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
x✝ x'✝ : Fin (succ n)
hx✝ : p x✝
hx'✝ : ¬p x'✝
⊢ f { val := x✝, property := hx✝ } ≠ f' { val := x'✝, property := hx'✝ }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | intro h | case im_disj
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
x✝ x'✝ : Fin (succ n)
hx✝ : p x✝
hx'✝ : ¬p x'✝
⊢ ¬f { val := x✝, property := hx✝ } = f' { val := x'✝, property := hx'✝ } | case im_disj
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
x✝ x'✝ : Fin (succ n)
hx✝ : p x✝
hx'✝ : ¬p x'✝
h : f { val := x✝, property := hx✝ } = f' { val := x'✝, property := hx'✝ }
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case im_disj
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
x✝ x'✝ : Fin (succ n)
hx✝ : p x✝
hx'✝ : ¬p x'✝
⊢ ¬f { val := x✝, property := hx✝ } = f' { val := x'✝, property := hx'✝ }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | apply ha | case im_disj
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
x✝ x'✝ : Fin (succ n)
hx✝ : p x✝
hx'✝ : ¬p x'✝
h : f { val := x✝, property := hx✝ } = f' { val := x'✝, property := hx'✝ }
⊢ False | case im_disj
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
x✝ x'✝ : Fin (succ n)
hx✝ : p x✝
hx'✝ : ¬p x'✝
h : f { val := x✝, property := hx✝ } = f' { val := x'✝, property := hx'✝ }
⊢ a ∈ Set.range x.toFun | Please generate a tactic in lean4 to solve the state.
STATE:
case im_disj
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
x✝ x'✝ : Fin (succ n)
hx✝ : p x✝
hx'✝ : ¬p x'✝
h : f { val := x✝, property := hx✝ } = f' { val := x'✝, property := hx'✝ }
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | refine ⟨_, h⟩ | case im_disj
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
x✝ x'✝ : Fin (succ n)
hx✝ : p x✝
hx'✝ : ¬p x'✝
h : f { val := x✝, property := hx✝ } = f' { val := x'✝, property := hx'✝ }
⊢ a ∈ Set.range x.toFun | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case im_disj
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
x✝ x'✝ : Fin (succ n)
hx✝ : p x✝
hx'✝ : ¬p x'✝
h : f { val := x✝, property := hx✝ } = f' { val := x'✝, property := hx'✝ }
⊢ a ∈ Set.range x.toFun
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | ext ⟨i, hi⟩ | case h.left
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
⊢ Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else f' { val := i, property := hi },
inj' := ⋯ } =
x | case h.left.h.mk
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : ℕ
hi : i < n
⊢ (Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else f' { val := i, property := hi },
inj' := ⋯ })
{ val := i, isLt := hi } =
x { val := i, isLt := hi } | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
⊢ Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else f' { val := i, property := hi },
inj' := ⋯ } =
x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | simp only [trans_apply, RelEmbedding.coe_toEmbedding, Fin.castLE_mk, coeFn_mk] | case h.left.h.mk
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : ℕ
hi : i < n
⊢ (Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else f' { val := i, property := hi },
inj' := ⋯ })
{ val := i, isLt := hi } =
x { val := i, isLt := hi } | case h.left.h.mk
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : ℕ
hi : i < n
⊢ (if hi_1 : p ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) then
f { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := hi_1 }
else f' { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := hi_1 }) =
x { val := i, isLt := hi } | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.h.mk
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : ℕ
hi : i < n
⊢ (Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else f' { val := i, property := hi },
inj' := ⋯ })
{ val := i, isLt := hi } =
x { val := i, isLt := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | rw [dite_eq_iff] | case h.left.h.mk
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : ℕ
hi : i < n
⊢ (if hi_1 : p ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) then
f { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := hi_1 }
else f' { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := hi_1 }) =
x { val := i, isLt := hi } | case h.left.h.mk
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : ℕ
hi : i < n
⊢ (∃ (h : p ((Fin.castLEEmb ⋯) { val := i, isLt := hi })),
f { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := h } = x { val := i, isLt := hi }) ∨
∃ (h : ¬p ((Fin.castLEEmb ⋯) { val := i, isLt := hi })),
f' { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := h } = x { val := i, isLt := hi } | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.h.mk
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : ℕ
hi : i < n
⊢ (if hi_1 : p ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) then
f { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := hi_1 }
else f' { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := hi_1 }) =
x { val := i, isLt := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | apply Or.intro_left | case h.left.h.mk
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : ℕ
hi : i < n
⊢ (∃ (h : p ((Fin.castLEEmb ⋯) { val := i, isLt := hi })),
f { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := h } = x { val := i, isLt := hi }) ∨
∃ (h : ¬p ((Fin.castLEEmb ⋯) { val := i, isLt := hi })),
f' { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := h } = x { val := i, isLt := hi } | case h.left.h.mk.h
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : ℕ
hi : i < n
⊢ ∃ (h : p ((Fin.castLEEmb ⋯) { val := i, isLt := hi })),
f { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := h } = x { val := i, isLt := hi } | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.h.mk
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : ℕ
hi : i < n
⊢ (∃ (h : p ((Fin.castLEEmb ⋯) { val := i, isLt := hi })),
f { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := h } = x { val := i, isLt := hi }) ∨
∃ (h : ¬p ((Fin.castLEEmb ⋯) { val := i, isLt := hi })),
f' { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := h } = x { val := i, isLt := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | use hi | case h.left.h.mk.h
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : ℕ
hi : i < n
⊢ ∃ (h : p ((Fin.castLEEmb ⋯) { val := i, isLt := hi })),
f { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := h } = x { val := i, isLt := hi } | case h
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : ℕ
hi : i < n
⊢ f { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := hi } = x { val := i, isLt := hi } | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.h.mk.h
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : ℕ
hi : i < n
⊢ ∃ (h : p ((Fin.castLEEmb ⋯) { val := i, isLt := hi })),
f { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := h } = x { val := i, isLt := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | rfl | case h
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : ℕ
hi : i < n
⊢ f { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := hi } = x { val := i, isLt := hi } | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
i : ℕ
hi : i < n
⊢ f { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := hi } = x { val := i, isLt := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with | [70, 1] | [102, 56] | simp only [gt_iff_lt, Set.coe_setOf, Set.mem_setOf_eq, toFun_eq_coe,
coeFn_mk, lt_self_iff_false, ↓reduceDite, p, f, f'] | case h.right
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
⊢ { toFun := fun i => if hi : p i then f { val := i, property := hi } else f' { val := i, property := hi }, inj' := ⋯ }
{ val := n, isLt := ⋯ } =
a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
α : Type u_1
n : ℕ
x : Fin n ↪ α
a : α
ha : a ∉ Set.range x.toFun
p : Fin (succ n) → Prop := fun i => ↑i < n
f : ↑{i | ↑i < n} → α := fun i => x.toFun (Fin.castLT ↑i ⋯)
f' : ↑{i | ¬p i} ↪ α :=
{
toFun := fun x =>
match x with
| { val := val, property := property } => a,
inj' := ⋯ }
⊢ { toFun := fun i => if hi : p i then f { val := i, property := hi } else f' { val := i, property := hi }, inj' := ⋯ }
{ val := n, isLt := ⋯ } =
a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend | [108, 1] | [131, 23] | induction' n with n hrec | α : Type u_1
m n : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
x : Fin m ↪ α
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x | case zero
α : Type u_1
m : ℕ
x : Fin m ↪ α
hmn : m ≤ zero
hα : ↑zero ≤ PartENat.card α
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
case succ
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
m n : ℕ
hmn : m ≤ n
hα : ↑n ≤ PartENat.card α
x : Fin m ↪ α
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend | [108, 1] | [131, 23] | simp only [Nat.zero_eq, nonpos_iff_eq_zero] at hmn | case zero
α : Type u_1
m : ℕ
x : Fin m ↪ α
hmn : m ≤ zero
hα : ↑zero ≤ PartENat.card α
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x | case zero
α : Type u_1
m : ℕ
x : Fin m ↪ α
hmn✝ : m ≤ zero
hα : ↑zero ≤ PartENat.card α
hmn : m = 0
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn✝).toEmbedding x' = x | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
α : Type u_1
m : ℕ
x : Fin m ↪ α
hmn : m ≤ zero
hα : ↑zero ≤ PartENat.card α
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend | [108, 1] | [131, 23] | let w : Fin 0 ↪ α := Function.Embedding.ofIsEmpty | case zero
α : Type u_1
m : ℕ
x : Fin m ↪ α
hmn✝ : m ≤ zero
hα : ↑zero ≤ PartENat.card α
hmn : m = 0
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn✝).toEmbedding x' = x | case zero
α : Type u_1
m : ℕ
x : Fin m ↪ α
hmn✝ : m ≤ zero
hα : ↑zero ≤ PartENat.card α
hmn : m = 0
w : Fin 0 ↪ α := Function.Embedding.ofIsEmpty
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn✝).toEmbedding x' = x | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
α : Type u_1
m : ℕ
x : Fin m ↪ α
hmn✝ : m ≤ zero
hα : ↑zero ≤ PartENat.card α
hmn : m = 0
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn✝).toEmbedding x' = x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend | [108, 1] | [131, 23] | use w | case zero
α : Type u_1
m : ℕ
x : Fin m ↪ α
hmn✝ : m ≤ zero
hα : ↑zero ≤ PartENat.card α
hmn : m = 0
w : Fin 0 ↪ α := Function.Embedding.ofIsEmpty
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn✝).toEmbedding x' = x | case h
α : Type u_1
m : ℕ
x : Fin m ↪ α
hmn✝ : m ≤ zero
hα : ↑zero ≤ PartENat.card α
hmn : m = 0
w : Fin 0 ↪ α := Function.Embedding.ofIsEmpty
⊢ Function.Embedding.trans (Fin.castLEEmb hmn✝).toEmbedding w = x | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
α : Type u_1
m : ℕ
x : Fin m ↪ α
hmn✝ : m ≤ zero
hα : ↑zero ≤ PartENat.card α
hmn : m = 0
w : Fin 0 ↪ α := Function.Embedding.ofIsEmpty
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn✝).toEmbedding x' = x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend | [108, 1] | [131, 23] | ext ⟨i, hi⟩ | case h
α : Type u_1
m : ℕ
x : Fin m ↪ α
hmn✝ : m ≤ zero
hα : ↑zero ≤ PartENat.card α
hmn : m = 0
w : Fin 0 ↪ α := Function.Embedding.ofIsEmpty
⊢ Function.Embedding.trans (Fin.castLEEmb hmn✝).toEmbedding w = x | case h.h.mk
α : Type u_1
m : ℕ
x : Fin m ↪ α
hmn✝ : m ≤ zero
hα : ↑zero ≤ PartENat.card α
hmn : m = 0
w : Fin 0 ↪ α := Function.Embedding.ofIsEmpty
i : ℕ
hi : i < m
⊢ (Function.Embedding.trans (Fin.castLEEmb hmn✝).toEmbedding w) { val := i, isLt := hi } = x { val := i, isLt := hi } | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
m : ℕ
x : Fin m ↪ α
hmn✝ : m ≤ zero
hα : ↑zero ≤ PartENat.card α
hmn : m = 0
w : Fin 0 ↪ α := Function.Embedding.ofIsEmpty
⊢ Function.Embedding.trans (Fin.castLEEmb hmn✝).toEmbedding w = x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend | [108, 1] | [131, 23] | exfalso | case h.h.mk
α : Type u_1
m : ℕ
x : Fin m ↪ α
hmn✝ : m ≤ zero
hα : ↑zero ≤ PartENat.card α
hmn : m = 0
w : Fin 0 ↪ α := Function.Embedding.ofIsEmpty
i : ℕ
hi : i < m
⊢ (Function.Embedding.trans (Fin.castLEEmb hmn✝).toEmbedding w) { val := i, isLt := hi } = x { val := i, isLt := hi } | case h.h.mk
α : Type u_1
m : ℕ
x : Fin m ↪ α
hmn✝ : m ≤ zero
hα : ↑zero ≤ PartENat.card α
hmn : m = 0
w : Fin 0 ↪ α := Function.Embedding.ofIsEmpty
i : ℕ
hi : i < m
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk
α : Type u_1
m : ℕ
x : Fin m ↪ α
hmn✝ : m ≤ zero
hα : ↑zero ≤ PartENat.card α
hmn : m = 0
w : Fin 0 ↪ α := Function.Embedding.ofIsEmpty
i : ℕ
hi : i < m
⊢ (Function.Embedding.trans (Fin.castLEEmb hmn✝).toEmbedding w) { val := i, isLt := hi } = x { val := i, isLt := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend | [108, 1] | [131, 23] | rw [hmn] at hi | case h.h.mk
α : Type u_1
m : ℕ
x : Fin m ↪ α
hmn✝ : m ≤ zero
hα : ↑zero ≤ PartENat.card α
hmn : m = 0
w : Fin 0 ↪ α := Function.Embedding.ofIsEmpty
i : ℕ
hi : i < m
⊢ False | case h.h.mk
α : Type u_1
m : ℕ
x : Fin m ↪ α
hmn✝ : m ≤ zero
hα : ↑zero ≤ PartENat.card α
hmn : m = 0
w : Fin 0 ↪ α := Function.Embedding.ofIsEmpty
i : ℕ
hi : i < 0
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk
α : Type u_1
m : ℕ
x : Fin m ↪ α
hmn✝ : m ≤ zero
hα : ↑zero ≤ PartENat.card α
hmn : m = 0
w : Fin 0 ↪ α := Function.Embedding.ofIsEmpty
i : ℕ
hi : i < m
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend | [108, 1] | [131, 23] | exact Nat.not_lt_zero i hi | case h.h.mk
α : Type u_1
m : ℕ
x : Fin m ↪ α
hmn✝ : m ≤ zero
hα : ↑zero ≤ PartENat.card α
hmn : m = 0
w : Fin 0 ↪ α := Function.Embedding.ofIsEmpty
i : ℕ
hi : i < 0
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk
α : Type u_1
m : ℕ
x : Fin m ↪ α
hmn✝ : m ≤ zero
hα : ↑zero ≤ PartENat.card α
hmn : m = 0
w : Fin 0 ↪ α := Function.Embedding.ofIsEmpty
i : ℕ
hi : i < 0
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend | [108, 1] | [131, 23] | cases Nat.eq_or_lt_of_le hmn with
| inl h =>
use (Equiv.toEmbedding (Fin.castIso h.symm).toEquiv).trans x
ext ⟨i, hi⟩
simp
| inr h =>
obtain ⟨y, hy⟩ :=
hrec (Nat.le_of_lt_succ h) (le_trans (PartENat.coe_le_coe.mpr (le_succ n)) hα)
obtain ⟨a, ha⟩ :=
gimme_another y (lt_of_lt_of_le (PartENat.coe_lt_coe.mpr (Nat.lt_succ_self n)) hα)
obtain ⟨x', hx', _⟩ := may_extend_with y a ha
use x'; rw [← hy]; rw [← hx']
ext ⟨i, hi⟩; rfl | case succ
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend | [108, 1] | [131, 23] | use (Equiv.toEmbedding (Fin.castIso h.symm).toEquiv).trans x | case succ.inl
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m = succ n
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x | case h
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m = succ n
⊢ Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x) =
x | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.inl
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m = succ n
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend | [108, 1] | [131, 23] | ext ⟨i, hi⟩ | case h
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m = succ n
⊢ Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x) =
x | case h.h.mk
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m = succ n
i : ℕ
hi : i < m
⊢ (Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x))
{ val := i, isLt := hi } =
x { val := i, isLt := hi } | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m = succ n
⊢ Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x) =
x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend | [108, 1] | [131, 23] | simp | case h.h.mk
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m = succ n
i : ℕ
hi : i < m
⊢ (Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x))
{ val := i, isLt := hi } =
x { val := i, isLt := hi } | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m = succ n
i : ℕ
hi : i < m
⊢ (Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x))
{ val := i, isLt := hi } =
x { val := i, isLt := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend | [108, 1] | [131, 23] | obtain ⟨y, hy⟩ :=
hrec (Nat.le_of_lt_succ h) (le_trans (PartENat.coe_le_coe.mpr (le_succ n)) hα) | case succ.inr
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m < succ n
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x | case succ.inr.intro
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m < succ n
y : Fin n ↪ α
hy : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y = x
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.inr
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m < succ n
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend | [108, 1] | [131, 23] | obtain ⟨a, ha⟩ :=
gimme_another y (lt_of_lt_of_le (PartENat.coe_lt_coe.mpr (Nat.lt_succ_self n)) hα) | case succ.inr.intro
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m < succ n
y : Fin n ↪ α
hy : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y = x
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x | case succ.inr.intro.intro
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m < succ n
y : Fin n ↪ α
hy : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y = x
a : α
ha : a ∉ Set.range ⇑y
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.inr.intro
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m < succ n
y : Fin n ↪ α
hy : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y = x
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend | [108, 1] | [131, 23] | obtain ⟨x', hx', _⟩ := may_extend_with y a ha | case succ.inr.intro.intro
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m < succ n
y : Fin n ↪ α
hy : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y = x
a : α
ha : a ∉ Set.range ⇑y
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x | case succ.inr.intro.intro.intro.intro
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m < succ n
y : Fin n ↪ α
hy : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y = x
a : α
ha : a ∉ Set.range ⇑y
x' : Fin (succ n) ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = y
right✝ : x' { val := n, isLt := ⋯ } = a
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.inr.intro.intro
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m < succ n
y : Fin n ↪ α
hy : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y = x
a : α
ha : a ∉ Set.range ⇑y
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend | [108, 1] | [131, 23] | use x' | case succ.inr.intro.intro.intro.intro
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m < succ n
y : Fin n ↪ α
hy : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y = x
a : α
ha : a ∉ Set.range ⇑y
x' : Fin (succ n) ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = y
right✝ : x' { val := n, isLt := ⋯ } = a
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x | case h
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m < succ n
y : Fin n ↪ α
hy : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y = x
a : α
ha : a ∉ Set.range ⇑y
x' : Fin (succ n) ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = y
right✝ : x' { val := n, isLt := ⋯ } = a
⊢ Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x | Please generate a tactic in lean4 to solve the state.
STATE:
case succ.inr.intro.intro.intro.intro
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m < succ n
y : Fin n ↪ α
hy : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y = x
a : α
ha : a ∉ Set.range ⇑y
x' : Fin (succ n) ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = y
right✝ : x' { val := n, isLt := ⋯ } = a
⊢ ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend | [108, 1] | [131, 23] | rw [← hy] | case h
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m < succ n
y : Fin n ↪ α
hy : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y = x
a : α
ha : a ∉ Set.range ⇑y
x' : Fin (succ n) ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = y
right✝ : x' { val := n, isLt := ⋯ } = a
⊢ Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x | case h
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m < succ n
y : Fin n ↪ α
hy : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y = x
a : α
ha : a ∉ Set.range ⇑y
x' : Fin (succ n) ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = y
right✝ : x' { val := n, isLt := ⋯ } = a
⊢ Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m < succ n
y : Fin n ↪ α
hy : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y = x
a : α
ha : a ∉ Set.range ⇑y
x' : Fin (succ n) ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = y
right✝ : x' { val := n, isLt := ⋯ } = a
⊢ Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend | [108, 1] | [131, 23] | rw [← hx'] | case h
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m < succ n
y : Fin n ↪ α
hy : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y = x
a : α
ha : a ∉ Set.range ⇑y
x' : Fin (succ n) ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = y
right✝ : x' { val := n, isLt := ⋯ } = a
⊢ Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y | case h
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m < succ n
y : Fin n ↪ α
hy : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y = x
a : α
ha : a ∉ Set.range ⇑y
x' : Fin (succ n) ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = y
right✝ : x' { val := n, isLt := ⋯ } = a
⊢ Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' =
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m < succ n
y : Fin n ↪ α
hy : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y = x
a : α
ha : a ∉ Set.range ⇑y
x' : Fin (succ n) ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = y
right✝ : x' { val := n, isLt := ⋯ } = a
⊢ Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend | [108, 1] | [131, 23] | ext ⟨i, hi⟩ | case h
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m < succ n
y : Fin n ↪ α
hy : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y = x
a : α
ha : a ∉ Set.range ⇑y
x' : Fin (succ n) ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = y
right✝ : x' { val := n, isLt := ⋯ } = a
⊢ Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' =
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x') | case h.h.mk
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m < succ n
y : Fin n ↪ α
hy : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y = x
a : α
ha : a ∉ Set.range ⇑y
x' : Fin (succ n) ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = y
right✝ : x' { val := n, isLt := ⋯ } = a
i : ℕ
hi : i < m
⊢ (Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x') { val := i, isLt := hi } =
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x'))
{ val := i, isLt := hi } | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m < succ n
y : Fin n ↪ α
hy : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y = x
a : α
ha : a ∉ Set.range ⇑y
x' : Fin (succ n) ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = y
right✝ : x' { val := n, isLt := ⋯ } = a
⊢ Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' =
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x')
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend | [108, 1] | [131, 23] | rfl | case h.h.mk
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m < succ n
y : Fin n ↪ α
hy : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y = x
a : α
ha : a ∉ Set.range ⇑y
x' : Fin (succ n) ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = y
right✝ : x' { val := n, isLt := ⋯ } = a
i : ℕ
hi : i < m
⊢ (Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x') { val := i, isLt := hi } =
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x'))
{ val := i, isLt := hi } | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mk
α : Type u_1
m : ℕ
x : Fin m ↪ α
n : ℕ
hrec : ∀ (hmn : m ≤ n), ↑n ≤ PartENat.card α → ∃ x', Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x' = x
hmn : m ≤ succ n
hα : ↑(succ n) ≤ PartENat.card α
h : m < succ n
y : Fin n ↪ α
hy : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding y = x
a : α
ha : a ∉ Set.range ⇑y
x' : Fin (succ n) ↪ α
hx' : Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = y
right✝ : x' { val := n, isLt := ⋯ } = a
i : ℕ
hi : i < m
⊢ (Function.Embedding.trans (Fin.castLEEmb hmn).toEmbedding x') { val := i, isLt := hi } =
(Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding (Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x'))
{ val := i, isLt := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | let h' := Eq.trans h (add_comm m k) | α : Type u_1
m n k : ℕ
s : Set α
z : Fin k ↪ ↑s
h : n = m + k
x : Fin m ↪ ↑sᶜ
⊢ ∃ x',
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ) ∧
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans z (subtype s) | α : Type u_1
m n k : ℕ
s : Set α
z : Fin k ↪ ↑s
h : n = m + k
x : Fin m ↪ ↑sᶜ
h' : n = k + m := h.trans (add_comm m k)
⊢ ∃ x',
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ) ∧
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans z (subtype s) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
m n k : ℕ
s : Set α
z : Fin k ↪ ↑s
h : n = m + k
x : Fin m ↪ ↑sᶜ
⊢ ∃ x',
Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding x' = Function.Embedding.trans x (subtype sᶜ) ∧
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv) x') =
Function.Embedding.trans z (subtype s)
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.