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/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | let p := fun i : Fin n => i.val < m | α : 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) | α : 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)
p : Fin n → Prop := fun i => ↑i < m
⊢ ∃ 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ᶜ
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)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | let f : {i : Fin n | p i} → α := fun i => x.toFun (Fin.castLT i.val i.prop) | α : 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)
p : Fin n → Prop := fun i => ↑i < m
⊢ ∃ 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
⊢ ∃ 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ᶜ
h' : n = k + m := h.trans (add_comm m k)
p : Fin n → Prop := fun i => ↑i < m
⊢ ∃ 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:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | let g : {i : Fin n | ¬p i} → α := fun i =>
z.toFun (Fin.subNat m (Fin.castIso h' i.val) (by simpa [h] using not_lt.mp (Subtype.mem i))) | α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
⊢ ∃ 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
⊢ ∃ 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ᶜ
h' : n = k + m := h.trans (add_comm m k)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
⊢ ∃ 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:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | constructor | case h
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
⊢ Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else g { val := i, property := hi },
inj' := ⋯ } =
Function.Embedding.trans x (subtype sᶜ) ∧
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv)
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else g { val := i, property := hi },
inj' := ⋯ }) =
Function.Embedding.trans z (subtype s) | case h.left
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
⊢ Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else g { val := i, property := hi },
inj' := ⋯ } =
Function.Embedding.trans x (subtype sᶜ)
case h.right
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
⊢ Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv)
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else g { val := i, property := hi },
inj' := ⋯ }) =
Function.Embedding.trans z (subtype s) | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
⊢ Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else g { val := i, property := hi },
inj' := ⋯ } =
Function.Embedding.trans x (subtype sᶜ) ∧
Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv)
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else g { val := i, property := hi },
inj' := ⋯ }) =
Function.Embedding.trans z (subtype s)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | simpa [h] using not_lt.mp (Subtype.mem i) | α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
i : ↑{i | ¬p i}
⊢ m ≤ ↑((Fin.castIso h') ↑i) | no goals | 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ᶜ
h' : n = k + m := h.trans (add_comm m k)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
i : ↑{i | ¬p i}
⊢ m ≤ ↑((Fin.castIso h') ↑i)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | refine' Function.Injective.dite p _ _ _ | α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
⊢ Function.Injective fun i => if hi : p i then f { val := i, property := hi } else g { val := i, property := hi } | case refine'_1
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
⊢ Function.Injective f
case refine'_2
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
⊢ Function.Injective g
case refine'_3
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
⊢ ∀ {x x' : Fin n} {hx : p x} {hx' : ¬p x'}, f { val := x, property := hx } ≠ g { val := x', property := hx' } | 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ᶜ
h' : n = k + m := h.trans (add_comm m k)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
⊢ Function.Injective fun i => if hi : p i then f { val := i, property := hi } else g { val := i, property := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | rintro ⟨i, hi⟩ ⟨j, hj⟩ hij | case refine'_1
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
⊢ Function.Injective f | case refine'_1.mk.mk
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi : p i
j : Fin 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 refine'_1
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
⊢ Function.Injective f
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | simpa only [Subtype.mk_eq_mk, Fin.ext_iff] using x.inj' (Subtype.coe_injective hij) | case refine'_1.mk.mk
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi : p i
j : Fin n
hj : p j
hij : f { val := i, property := hi } = f { val := j, property := hj }
⊢ { val := i, property := hi } = { val := j, property := hj } | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refine'_1.mk.mk
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi : p i
j : Fin 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' | [135, 1] | [179, 8] | rintro ⟨i, hi⟩ ⟨j, hj⟩ hij | case refine'_2
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
⊢ Function.Injective g | case refine'_2.mk.mk
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi : ¬p i
j : Fin n
hj : ¬p j
hij : g { val := i, property := hi } = g { val := j, property := hj }
⊢ { val := i, property := hi } = { val := j, property := hj } | Please generate a tactic in lean4 to solve the state.
STATE:
case refine'_2
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
⊢ Function.Injective g
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | simp only [Subtype.mk_eq_mk] | case refine'_2.mk.mk
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi : ¬p i
j : Fin n
hj : ¬p j
hij : g { val := i, property := hi } = g { val := j, property := hj }
⊢ { val := i, property := hi } = { val := j, property := hj } | case refine'_2.mk.mk
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi : ¬p i
j : Fin n
hj : ¬p j
hij : g { val := i, property := hi } = g { val := j, property := hj }
⊢ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
case refine'_2.mk.mk
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi : ¬p i
j : Fin n
hj : ¬p j
hij : g { val := i, property := hi } = g { 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' | [135, 1] | [179, 8] | apply (Fin.castIso h').injective | case refine'_2.mk.mk
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi : ¬p i
j : Fin n
hj : ¬p j
hij : g { val := i, property := hi } = g { val := j, property := hj }
⊢ i = j | case refine'_2.mk.mk.a
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi : ¬p i
j : Fin n
hj : ¬p j
hij : g { val := i, property := hi } = g { val := j, property := hj }
⊢ (Fin.castIso h') i = (Fin.castIso h') j | Please generate a tactic in lean4 to solve the state.
STATE:
case refine'_2.mk.mk
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi : ¬p i
j : Fin n
hj : ¬p j
hij : g { val := i, property := hi } = g { val := j, property := hj }
⊢ i = j
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | rw [not_lt] at hi hj | case refine'_2.mk.mk.a
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi : ¬p i
j : Fin n
hj : ¬p j
hij : g { val := i, property := hi } = g { val := j, property := hj }
⊢ (Fin.castIso h') i = (Fin.castIso h') j | case refine'_2.mk.mk.a
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi✝ : ¬p i
hi : m ≤ ↑i
j : Fin n
hj✝ : ¬p j
hj : m ≤ ↑j
hij : g { val := i, property := hi✝ } = g { val := j, property := hj✝ }
⊢ (Fin.castIso h') i = (Fin.castIso h') j | Please generate a tactic in lean4 to solve the state.
STATE:
case refine'_2.mk.mk.a
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi : ¬p i
j : Fin n
hj : ¬p j
hij : g { val := i, property := hi } = g { val := j, property := hj }
⊢ (Fin.castIso h') i = (Fin.castIso h') j
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | have hi' : m ≤ (Fin.castIso h') i := by simp only [Fin.coe_orderIso_apply]; exact hi | case refine'_2.mk.mk.a
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi✝ : ¬p i
hi : m ≤ ↑i
j : Fin n
hj✝ : ¬p j
hj : m ≤ ↑j
hij : g { val := i, property := hi✝ } = g { val := j, property := hj✝ }
⊢ (Fin.castIso h') i = (Fin.castIso h') j | case refine'_2.mk.mk.a
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi✝ : ¬p i
hi : m ≤ ↑i
j : Fin n
hj✝ : ¬p j
hj : m ≤ ↑j
hij : g { val := i, property := hi✝ } = g { val := j, property := hj✝ }
hi' : m ≤ ↑((Fin.castIso h') i)
⊢ (Fin.castIso h') i = (Fin.castIso h') j | Please generate a tactic in lean4 to solve the state.
STATE:
case refine'_2.mk.mk.a
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi✝ : ¬p i
hi : m ≤ ↑i
j : Fin n
hj✝ : ¬p j
hj : m ≤ ↑j
hij : g { val := i, property := hi✝ } = g { val := j, property := hj✝ }
⊢ (Fin.castIso h') i = (Fin.castIso h') j
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | have hj' : m ≤ (Fin.castIso h') j := by simp only [Fin.coe_orderIso_apply]; exact hj | case refine'_2.mk.mk.a
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi✝ : ¬p i
hi : m ≤ ↑i
j : Fin n
hj✝ : ¬p j
hj : m ≤ ↑j
hij : g { val := i, property := hi✝ } = g { val := j, property := hj✝ }
hi' : m ≤ ↑((Fin.castIso h') i)
⊢ (Fin.castIso h') i = (Fin.castIso h') j | case refine'_2.mk.mk.a
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi✝ : ¬p i
hi : m ≤ ↑i
j : Fin n
hj✝ : ¬p j
hj : m ≤ ↑j
hij : g { val := i, property := hi✝ } = g { val := j, property := hj✝ }
hi' : m ≤ ↑((Fin.castIso h') i)
hj' : m ≤ ↑((Fin.castIso h') j)
⊢ (Fin.castIso h') i = (Fin.castIso h') j | Please generate a tactic in lean4 to solve the state.
STATE:
case refine'_2.mk.mk.a
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi✝ : ¬p i
hi : m ≤ ↑i
j : Fin n
hj✝ : ¬p j
hj : m ≤ ↑j
hij : g { val := i, property := hi✝ } = g { val := j, property := hj✝ }
hi' : m ≤ ↑((Fin.castIso h') i)
⊢ (Fin.castIso h') i = (Fin.castIso h') j
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | let hij' := z.inj' (Subtype.coe_injective hij) | case refine'_2.mk.mk.a
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi✝ : ¬p i
hi : m ≤ ↑i
j : Fin n
hj✝ : ¬p j
hj : m ≤ ↑j
hij : g { val := i, property := hi✝ } = g { val := j, property := hj✝ }
hi' : m ≤ ↑((Fin.castIso h') i)
hj' : m ≤ ↑((Fin.castIso h') j)
⊢ (Fin.castIso h') i = (Fin.castIso h') j | case refine'_2.mk.mk.a
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi✝ : ¬p i
hi : m ≤ ↑i
j : Fin n
hj✝ : ¬p j
hj : m ≤ ↑j
hij : g { val := i, property := hi✝ } = g { val := j, property := hj✝ }
hi' : m ≤ ↑((Fin.castIso h') i)
hj' : m ≤ ↑((Fin.castIso h') j)
hij' : Fin.subNat m ((Fin.castIso h') ↑{ val := i, property := hi✝ }) ⋯ =
Fin.subNat m ((Fin.castIso h') ↑{ val := j, property := hj✝ }) ⋯ :=
z.inj' (Subtype.coe_injective hij)
⊢ (Fin.castIso h') i = (Fin.castIso h') j | Please generate a tactic in lean4 to solve the state.
STATE:
case refine'_2.mk.mk.a
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi✝ : ¬p i
hi : m ≤ ↑i
j : Fin n
hj✝ : ¬p j
hj : m ≤ ↑j
hij : g { val := i, property := hi✝ } = g { val := j, property := hj✝ }
hi' : m ≤ ↑((Fin.castIso h') i)
hj' : m ≤ ↑((Fin.castIso h') j)
⊢ (Fin.castIso h') i = (Fin.castIso h') j
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | simp only at hij' | case refine'_2.mk.mk.a
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi✝ : ¬p i
hi : m ≤ ↑i
j : Fin n
hj✝ : ¬p j
hj : m ≤ ↑j
hij : g { val := i, property := hi✝ } = g { val := j, property := hj✝ }
hi' : m ≤ ↑((Fin.castIso h') i)
hj' : m ≤ ↑((Fin.castIso h') j)
hij' : Fin.subNat m ((Fin.castIso h') ↑{ val := i, property := hi✝ }) ⋯ =
Fin.subNat m ((Fin.castIso h') ↑{ val := j, property := hj✝ }) ⋯ :=
z.inj' (Subtype.coe_injective hij)
⊢ (Fin.castIso h') i = (Fin.castIso h') j | case refine'_2.mk.mk.a
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi✝ : ¬p i
hi : m ≤ ↑i
j : Fin n
hj✝ : ¬p j
hj : m ≤ ↑j
hij : g { val := i, property := hi✝ } = g { val := j, property := hj✝ }
hi' : m ≤ ↑((Fin.castIso h') i)
hj' : m ≤ ↑((Fin.castIso h') j)
hij' : Fin.subNat m ((Fin.castIso h') i) ⋯ = Fin.subNat m ((Fin.castIso h') j) ⋯ := z.inj' (Subtype.coe_injective hij)
⊢ (Fin.castIso h') i = (Fin.castIso h') j | Please generate a tactic in lean4 to solve the state.
STATE:
case refine'_2.mk.mk.a
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi✝ : ¬p i
hi : m ≤ ↑i
j : Fin n
hj✝ : ¬p j
hj : m ≤ ↑j
hij : g { val := i, property := hi✝ } = g { val := j, property := hj✝ }
hi' : m ≤ ↑((Fin.castIso h') i)
hj' : m ≤ ↑((Fin.castIso h') j)
hij' : Fin.subNat m ((Fin.castIso h') ↑{ val := i, property := hi✝ }) ⋯ =
Fin.subNat m ((Fin.castIso h') ↑{ val := j, property := hj✝ }) ⋯ :=
z.inj' (Subtype.coe_injective hij)
⊢ (Fin.castIso h') i = (Fin.castIso h') j
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | rw [← Fin.addNat_subNat hi', ← Fin.addNat_subNat hj', hij'] | case refine'_2.mk.mk.a
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi✝ : ¬p i
hi : m ≤ ↑i
j : Fin n
hj✝ : ¬p j
hj : m ≤ ↑j
hij : g { val := i, property := hi✝ } = g { val := j, property := hj✝ }
hi' : m ≤ ↑((Fin.castIso h') i)
hj' : m ≤ ↑((Fin.castIso h') j)
hij' : Fin.subNat m ((Fin.castIso h') i) ⋯ = Fin.subNat m ((Fin.castIso h') j) ⋯ := z.inj' (Subtype.coe_injective hij)
⊢ (Fin.castIso h') i = (Fin.castIso h') j | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refine'_2.mk.mk.a
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi✝ : ¬p i
hi : m ≤ ↑i
j : Fin n
hj✝ : ¬p j
hj : m ≤ ↑j
hij : g { val := i, property := hi✝ } = g { val := j, property := hj✝ }
hi' : m ≤ ↑((Fin.castIso h') i)
hj' : m ≤ ↑((Fin.castIso h') j)
hij' : Fin.subNat m ((Fin.castIso h') i) ⋯ = Fin.subNat m ((Fin.castIso h') j) ⋯ := z.inj' (Subtype.coe_injective hij)
⊢ (Fin.castIso h') i = (Fin.castIso h') j
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | simp only [Fin.coe_orderIso_apply] | α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi✝ : ¬p i
hi : m ≤ ↑i
j : Fin n
hj✝ : ¬p j
hj : m ≤ ↑j
hij : g { val := i, property := hi✝ } = g { val := j, property := hj✝ }
⊢ m ≤ ↑((Fin.castIso h') i) | α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi✝ : ¬p i
hi : m ≤ ↑i
j : Fin n
hj✝ : ¬p j
hj : m ≤ ↑j
hij : g { val := i, property := hi✝ } = g { val := j, property := hj✝ }
⊢ m ≤ ↑i | 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ᶜ
h' : n = k + m := h.trans (add_comm m k)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi✝ : ¬p i
hi : m ≤ ↑i
j : Fin n
hj✝ : ¬p j
hj : m ≤ ↑j
hij : g { val := i, property := hi✝ } = g { val := j, property := hj✝ }
⊢ m ≤ ↑((Fin.castIso h') i)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | exact hi | α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi✝ : ¬p i
hi : m ≤ ↑i
j : Fin n
hj✝ : ¬p j
hj : m ≤ ↑j
hij : g { val := i, property := hi✝ } = g { val := j, property := hj✝ }
⊢ m ≤ ↑i | no goals | 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ᶜ
h' : n = k + m := h.trans (add_comm m k)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi✝ : ¬p i
hi : m ≤ ↑i
j : Fin n
hj✝ : ¬p j
hj : m ≤ ↑j
hij : g { val := i, property := hi✝ } = g { val := j, property := hj✝ }
⊢ m ≤ ↑i
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | simp only [Fin.coe_orderIso_apply] | α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi✝ : ¬p i
hi : m ≤ ↑i
j : Fin n
hj✝ : ¬p j
hj : m ≤ ↑j
hij : g { val := i, property := hi✝ } = g { val := j, property := hj✝ }
hi' : m ≤ ↑((Fin.castIso h') i)
⊢ m ≤ ↑((Fin.castIso h') j) | α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi✝ : ¬p i
hi : m ≤ ↑i
j : Fin n
hj✝ : ¬p j
hj : m ≤ ↑j
hij : g { val := i, property := hi✝ } = g { val := j, property := hj✝ }
hi' : m ≤ ↑((Fin.castIso h') i)
⊢ m ≤ ↑j | 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ᶜ
h' : n = k + m := h.trans (add_comm m k)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi✝ : ¬p i
hi : m ≤ ↑i
j : Fin n
hj✝ : ¬p j
hj : m ≤ ↑j
hij : g { val := i, property := hi✝ } = g { val := j, property := hj✝ }
hi' : m ≤ ↑((Fin.castIso h') i)
⊢ m ≤ ↑((Fin.castIso h') j)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | exact hj | α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi✝ : ¬p i
hi : m ≤ ↑i
j : Fin n
hj✝ : ¬p j
hj : m ≤ ↑j
hij : g { val := i, property := hi✝ } = g { val := j, property := hj✝ }
hi' : m ≤ ↑((Fin.castIso h') i)
⊢ m ≤ ↑j | no goals | 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ᶜ
h' : n = k + m := h.trans (add_comm m k)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : Fin n
hi✝ : ¬p i
hi : m ≤ ↑i
j : Fin n
hj✝ : ¬p j
hj : m ≤ ↑j
hij : g { val := i, property := hi✝ } = g { val := j, property := hj✝ }
hi' : m ≤ ↑((Fin.castIso h') i)
⊢ m ≤ ↑j
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | intro i j hi hj hij | case refine'_3
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
⊢ ∀ {x x' : Fin n} {hx : p x} {hx' : ¬p x'}, f { val := x, property := hx } ≠ g { val := x', property := hx' } | case refine'_3
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i j : Fin n
hi : p i
hj : ¬p j
hij : f { val := i, property := hi } = g { val := j, property := hj }
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case refine'_3
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
⊢ ∀ {x x' : Fin n} {hx : p x} {hx' : ¬p x'}, f { val := x, property := hx } ≠ g { val := x', property := hx' }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | suffices f ⟨i, hi⟩ ∉ s by
apply this
rw [hij]
simp only [Set.coe_setOf, Set.mem_setOf_eq, Fin.castIso_apply,
toFun_eq_coe, Subtype.coe_prop, g] | case refine'_3
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i j : Fin n
hi : p i
hj : ¬p j
hij : f { val := i, property := hi } = g { val := j, property := hj }
⊢ False | case refine'_3
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i j : Fin n
hi : p i
hj : ¬p j
hij : f { val := i, property := hi } = g { val := j, property := hj }
⊢ f { val := i, property := hi } ∉ s | Please generate a tactic in lean4 to solve the state.
STATE:
case refine'_3
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i j : Fin n
hi : p i
hj : ¬p j
hij : f { val := i, property := hi } = g { val := j, property := hj }
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | simp only [f, ← Set.mem_compl_iff, Subtype.coe_prop] | case refine'_3
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i j : Fin n
hi : p i
hj : ¬p j
hij : f { val := i, property := hi } = g { val := j, property := hj }
⊢ f { val := i, property := hi } ∉ s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refine'_3
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i j : Fin n
hi : p i
hj : ¬p j
hij : f { val := i, property := hi } = g { val := j, property := hj }
⊢ f { val := i, property := hi } ∉ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | apply this | α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i j : Fin n
hi : p i
hj : ¬p j
hij : f { val := i, property := hi } = g { val := j, property := hj }
this : f { val := i, property := hi } ∉ s
⊢ False | α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i j : Fin n
hi : p i
hj : ¬p j
hij : f { val := i, property := hi } = g { val := j, property := hj }
this : f { val := i, property := hi } ∉ s
⊢ f { val := i, property := hi } ∈ 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ᶜ
h' : n = k + m := h.trans (add_comm m k)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i j : Fin n
hi : p i
hj : ¬p j
hij : f { val := i, property := hi } = g { val := j, property := hj }
this : f { val := i, property := hi } ∉ s
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | rw [hij] | α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i j : Fin n
hi : p i
hj : ¬p j
hij : f { val := i, property := hi } = g { val := j, property := hj }
this : f { val := i, property := hi } ∉ s
⊢ f { val := i, property := hi } ∈ 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i j : Fin n
hi : p i
hj : ¬p j
hij : f { val := i, property := hi } = g { val := j, property := hj }
this : f { val := i, property := hi } ∉ s
⊢ g { val := j, property := hj } ∈ 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ᶜ
h' : n = k + m := h.trans (add_comm m k)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i j : Fin n
hi : p i
hj : ¬p j
hij : f { val := i, property := hi } = g { val := j, property := hj }
this : f { val := i, property := hi } ∉ s
⊢ f { val := i, property := hi } ∈ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | simp only [Set.coe_setOf, Set.mem_setOf_eq, Fin.castIso_apply,
toFun_eq_coe, Subtype.coe_prop, g] | α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i j : Fin n
hi : p i
hj : ¬p j
hij : f { val := i, property := hi } = g { val := j, property := hj }
this : f { val := i, property := hi } ∉ s
⊢ g { val := j, property := hj } ∈ s | no goals | 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ᶜ
h' : n = k + m := h.trans (add_comm m k)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i j : Fin n
hi : p i
hj : ¬p j
hij : f { val := i, property := hi } = g { val := j, property := hj }
this : f { val := i, property := hi } ∉ s
⊢ g { val := j, property := hj } ∈ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | ext ⟨i, hi⟩ | case h.left
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
⊢ Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else g { val := i, property := hi },
inj' := ⋯ } =
Function.Embedding.trans x (subtype sᶜ) | case h.left.h.mk
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : ℕ
hi : i < m
⊢ (Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else g { val := i, property := hi },
inj' := ⋯ })
{ val := i, isLt := hi } =
(Function.Embedding.trans x (subtype sᶜ)) { val := i, isLt := hi } | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
⊢ Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else g { val := i, property := hi },
inj' := ⋯ } =
Function.Embedding.trans x (subtype sᶜ)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | simp only [trans_apply, RelEmbedding.coe_toEmbedding, Fin.castLE_mk, coeFn_mk] | case h.left.h.mk
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : ℕ
hi : i < m
⊢ (Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else g { val := i, property := hi },
inj' := ⋯ })
{ val := i, isLt := hi } =
(Function.Embedding.trans x (subtype sᶜ)) { val := i, isLt := hi } | case h.left.h.mk
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : ℕ
hi : i < m
⊢ (if hi_1 : p ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) then
f { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := hi_1 }
else g { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := hi_1 }) =
(subtype sᶜ) (x { val := i, isLt := hi }) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.h.mk
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : ℕ
hi : i < m
⊢ (Function.Embedding.trans (Fin.castLEEmb ⋯).toEmbedding
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else g { val := i, property := hi },
inj' := ⋯ })
{ val := i, isLt := hi } =
(Function.Embedding.trans x (subtype sᶜ)) { val := i, isLt := hi }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | rw [dite_eq_iff] | case h.left.h.mk
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : ℕ
hi : i < m
⊢ (if hi_1 : p ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) then
f { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := hi_1 }
else g { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := hi_1 }) =
(subtype sᶜ) (x { val := i, isLt := hi }) | case h.left.h.mk
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : ℕ
hi : i < m
⊢ (∃ (h_1 : p ((Fin.castLEEmb ⋯) { val := i, isLt := hi })),
f { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := h_1 } =
(subtype sᶜ) (x { val := i, isLt := hi })) ∨
∃ (h_1 : ¬p ((Fin.castLEEmb ⋯) { val := i, isLt := hi })),
g { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := h_1 } =
(subtype sᶜ) (x { val := i, isLt := hi }) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.h.mk
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : ℕ
hi : i < m
⊢ (if hi_1 : p ((Fin.castLEEmb ⋯) { val := i, isLt := hi }) then
f { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := hi_1 }
else g { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := hi_1 }) =
(subtype sᶜ) (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] | apply Or.intro_left | case h.left.h.mk
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : ℕ
hi : i < m
⊢ (∃ (h_1 : p ((Fin.castLEEmb ⋯) { val := i, isLt := hi })),
f { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := h_1 } =
(subtype sᶜ) (x { val := i, isLt := hi })) ∨
∃ (h_1 : ¬p ((Fin.castLEEmb ⋯) { val := i, isLt := hi })),
g { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := h_1 } =
(subtype sᶜ) (x { val := i, isLt := hi }) | case h.left.h.mk.h
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : ℕ
hi : i < m
⊢ ∃ (h_1 : p ((Fin.castLEEmb ⋯) { val := i, isLt := hi })),
f { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := h_1 } = (subtype sᶜ) (x { val := i, isLt := hi }) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left.h.mk
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : ℕ
hi : i < m
⊢ (∃ (h_1 : p ((Fin.castLEEmb ⋯) { val := i, isLt := hi })),
f { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := h_1 } =
(subtype sᶜ) (x { val := i, isLt := hi })) ∨
∃ (h_1 : ¬p ((Fin.castLEEmb ⋯) { val := i, isLt := hi })),
g { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := h_1 } =
(subtype sᶜ) (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] | use hi | case h.left.h.mk.h
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : ℕ
hi : i < m
⊢ ∃ (h_1 : p ((Fin.castLEEmb ⋯) { val := i, isLt := hi })),
f { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := h_1 } = (subtype sᶜ) (x { val := i, isLt := hi }) | case h
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : ℕ
hi : i < m
⊢ f { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := hi } = (subtype sᶜ) (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
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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : ℕ
hi : i < m
⊢ ∃ (h_1 : p ((Fin.castLEEmb ⋯) { val := i, isLt := hi })),
f { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := h_1 } = (subtype sᶜ) (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] | rfl | case h
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : ℕ
hi : i < m
⊢ f { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := hi } = (subtype sᶜ) (x { val := i, isLt := hi }) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
i : ℕ
hi : i < m
⊢ f { val := (Fin.castLEEmb ⋯) { val := i, isLt := hi }, property := hi } = (subtype sᶜ) (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] | ext ⟨j, hj⟩ | case h.right
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
⊢ Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv)
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else g { val := i, property := hi },
inj' := ⋯ }) =
Function.Embedding.trans z (subtype s) | case h.right.h.mk
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
j : ℕ
hj : j < k
⊢ (Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv)
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else g { val := i, property := hi },
inj' := ⋯ }))
{ val := j, isLt := hj } =
(Function.Embedding.trans z (subtype s)) { val := j, isLt := hj } | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
⊢ Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv)
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else g { val := i, property := hi },
inj' := ⋯ }) =
Function.Embedding.trans z (subtype s)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | simp only [Fin.natAddEmb_toEmbedding, gt_iff_lt, Set.coe_setOf, Set.mem_setOf_eq, toFun_eq_coe,
Fin.castIso_apply, trans_apply, coeFn_mk, Fin.natAdd_mk, Equiv.coe_toEmbedding,
RelIso.coe_fn_toEquiv, Fin.cast_mk, add_lt_iff_neg_left, not_lt_zero', ↓reduceDite,
Fin.subNat_mk, add_tsub_cancel_left, p, f, g] | case h.right.h.mk
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
j : ℕ
hj : j < k
⊢ (Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv)
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else g { val := i, property := hi },
inj' := ⋯ }))
{ val := j, isLt := hj } =
(Function.Embedding.trans z (subtype s)) { val := j, isLt := hj } | case h.right.h.mk
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
j : ℕ
hj : j < k
⊢ ↑(z { val := j, isLt := ⋯ }) = (subtype s) (z { val := j, isLt := hj }) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right.h.mk
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
j : ℕ
hj : j < k
⊢ (Function.Embedding.trans (Fin.natAddEmb m).toEmbedding
(Function.Embedding.trans (Equiv.toEmbedding (Fin.castIso ⋯).toEquiv)
{ toFun := fun i => if hi : p i then f { val := i, property := hi } else g { val := i, property := hi },
inj' := ⋯ }))
{ val := j, isLt := hj } =
(Function.Embedding.trans z (subtype s)) { val := j, isLt := hj }
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Extensions.lean | may_extend_with' | [135, 1] | [179, 8] | rfl | case h.right.h.mk
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
j : ℕ
hj : j < k
⊢ ↑(z { val := j, isLt := ⋯ }) = (subtype s) (z { val := j, isLt := hj }) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right.h.mk
α : 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)
p : Fin n → Prop := fun i => ↑i < m
f : ↑{i | p i} → α := fun i => ↑(x.toFun (Fin.castLT ↑i ⋯))
g : ↑{i | ¬p i} → α := fun i => ↑(z.toFun (Fin.subNat m ((Fin.castIso h') ↑i) ⋯))
j : ℕ
hj : j < k
⊢ ↑(z { val := j, isLt := ⋯ }) = (subtype s) (z { val := j, isLt := hj })
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isPretransitive_of_submonoid | [41, 1] | [47, 17] | let h_eq := h.exists_smul_eq | M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
K : Submonoid M
h : IsPretransitive (↥K) α
⊢ IsPretransitive M α | M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
K : Submonoid M
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ IsPretransitive M α | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
K : Submonoid M
h : IsPretransitive (↥K) α
⊢ IsPretransitive M α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isPretransitive_of_submonoid | [41, 1] | [47, 17] | apply IsPretransitive.mk | M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
K : Submonoid M
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ IsPretransitive M α | case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
K : Submonoid M
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (x y : α), ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
K : Submonoid M
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ IsPretransitive M α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isPretransitive_of_submonoid | [41, 1] | [47, 17] | intro x y | case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
K : Submonoid M
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (x y : α), ∃ g, g • x = y | case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
K : Submonoid M
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : α
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
K : Submonoid M
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (x y : α), ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isPretransitive_of_submonoid | [41, 1] | [47, 17] | obtain ⟨⟨k, hk⟩, hk'⟩ := h_eq x y | case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
K : Submonoid M
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : α
⊢ ∃ g, g • x = y | case exists_smul_eq.intro.mk
M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
K : Submonoid M
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : α
k : M
hk : k ∈ K
hk' : { val := k, property := hk } • x = y
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
K : Submonoid M
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : α
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isPretransitive_of_submonoid | [41, 1] | [47, 17] | exact ⟨k, hk'⟩ | case exists_smul_eq.intro.mk
M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
K : Submonoid M
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : α
k : M
hk : k ∈ K
hk' : { val := k, property := hk } • x = y
⊢ ∃ g, g • x = y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq.intro.mk
M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
K : Submonoid M
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : α
k : M
hk : k ∈ K
hk' : { val := k, property := hk } • x = y
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isPretransitive_of_submonoid_le | [50, 1] | [58, 12] | let h_eq := h.exists_smul_eq | M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
G K : Submonoid M
hKG : K ≤ G
h : IsPretransitive (↥K) α
⊢ IsPretransitive (↥G) α | M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
G K : Submonoid M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ IsPretransitive (↥G) α | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
G K : Submonoid M
hKG : K ≤ G
h : IsPretransitive (↥K) α
⊢ IsPretransitive (↥G) α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isPretransitive_of_submonoid_le | [50, 1] | [58, 12] | apply IsPretransitive.mk | M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
G K : Submonoid M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ IsPretransitive (↥G) α | case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
G K : Submonoid M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (x y : α), ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
G K : Submonoid M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ IsPretransitive (↥G) α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isPretransitive_of_submonoid_le | [50, 1] | [58, 12] | intro x y | case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
G K : Submonoid M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (x y : α), ∃ g, g • x = y | case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
G K : Submonoid M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : α
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
G K : Submonoid M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (x y : α), ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isPretransitive_of_submonoid_le | [50, 1] | [58, 12] | obtain ⟨⟨k, hk⟩, hk'⟩ := h_eq x y | case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
G K : Submonoid M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : α
⊢ ∃ g, g • x = y | case exists_smul_eq.intro.mk
M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
G K : Submonoid M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : α
k : M
hk : k ∈ K
hk' : { val := k, property := hk } • x = y
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
G K : Submonoid M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : α
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isPretransitive_of_submonoid_le | [50, 1] | [58, 12] | use ⟨k, hKG hk⟩ | case exists_smul_eq.intro.mk
M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
G K : Submonoid M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : α
k : M
hk : k ∈ K
hk' : { val := k, property := hk } • x = y
⊢ ∃ g, g • x = y | case h
M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
G K : Submonoid M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : α
k : M
hk : k ∈ K
hk' : { val := k, property := hk } • x = y
⊢ { val := k, property := ⋯ } • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq.intro.mk
M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
G K : Submonoid M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : α
k : M
hk : k ∈ K
hk' : { val := k, property := hk } • x = y
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isPretransitive_of_submonoid_le | [50, 1] | [58, 12] | exact hk' | case h
M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
G K : Submonoid M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : α
k : M
hk : k ∈ K
hk' : { val := k, property := hk } • x = y
⊢ { val := k, property := ⋯ } • x = y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type u_1
α : Type u_2
inst✝² : DecidableEq α
inst✝¹ : Monoid M
inst✝ : MulAction M α
G K : Submonoid M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : α
k : M
hk : k ∈ K
hk' : { val := k, property := hk } • x = y
⊢ { val := k, property := ⋯ } • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.card_orbit_eq_stabilizer_index | [68, 1] | [72, 41] | rw [← Set.Nat.card_coe_set_eq] | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
⊢ Set.ncard (orbit M a) = Subgroup.index (stabilizer M a) | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
⊢ Nat.card ↑(orbit M a) = Subgroup.index (stabilizer M a) | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
⊢ Set.ncard (orbit M a) = Subgroup.index (stabilizer M a)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.card_orbit_eq_stabilizer_index | [68, 1] | [72, 41] | apply Nat.card_congr | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
⊢ Nat.card ↑(orbit M a) = Subgroup.index (stabilizer M a) | case f
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
⊢ ↑(orbit M a) ≃ M ⧸ stabilizer M a | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
⊢ Nat.card ↑(orbit M a) = Subgroup.index (stabilizer M a)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.card_orbit_eq_stabilizer_index | [68, 1] | [72, 41] | exact orbitEquivQuotientStabilizer M a | case f
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
⊢ ↑(orbit M a) ≃ M ⧸ stabilizer M a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case f
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
⊢ ↑(orbit M a) ≃ M ⧸ stabilizer M a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer_index_of_pretransitive | [77, 1] | [81, 26] | rw [← card_orbit_eq_stabilizer_index] | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
h : IsPretransitive M α
a : α
⊢ Subgroup.index (stabilizer M a) = Nat.card α | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
h : IsPretransitive M α
a : α
⊢ Set.ncard (orbit M a) = Nat.card α | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
h : IsPretransitive M α
a : α
⊢ Subgroup.index (stabilizer M a) = Nat.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer_index_of_pretransitive | [77, 1] | [81, 26] | convert Set.ncard_univ α | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
h : IsPretransitive M α
a : α
⊢ Set.ncard (orbit M a) = Nat.card α | case h.e'_2.h.e'_2
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
h : IsPretransitive M α
a : α
⊢ orbit M a = Set.univ | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
h : IsPretransitive M α
a : α
⊢ Set.ncard (orbit M a) = Nat.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.stabilizer_index_of_pretransitive | [77, 1] | [81, 26] | exact orbit_eq_univ M a | case h.e'_2.h.e'_2
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
h : IsPretransitive M α
a : α
⊢ orbit M a = Set.univ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_2.h.e'_2
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
h : IsPretransitive M α
a : α
⊢ orbit M a = Set.univ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isPretransitive_of_subgroup | [86, 1] | [90, 10] | apply isPretransitive_of_submonoid | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
K : Subgroup M
h : IsPretransitive (↥K) α
⊢ IsPretransitive M α | case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
K : Subgroup M
h : IsPretransitive (↥K) α
⊢ IsPretransitive (↥?K) α
case K
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
K : Subgroup M
h : IsPretransitive (↥K) α
⊢ Submonoid M | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
K : Subgroup M
h : IsPretransitive (↥K) α
⊢ IsPretransitive M α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isPretransitive_of_subgroup | [86, 1] | [90, 10] | swap | case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
K : Subgroup M
h : IsPretransitive (↥K) α
⊢ IsPretransitive (↥?K) α
case K
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
K : Subgroup M
h : IsPretransitive (↥K) α
⊢ Submonoid M | case K
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
K : Subgroup M
h : IsPretransitive (↥K) α
⊢ Submonoid M
case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
K : Subgroup M
h : IsPretransitive (↥K) α
⊢ IsPretransitive (↥?K) α | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
K : Subgroup M
h : IsPretransitive (↥K) α
⊢ IsPretransitive (↥?K) α
case K
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
K : Subgroup M
h : IsPretransitive (↥K) α
⊢ Submonoid M
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isPretransitive_of_subgroup | [86, 1] | [90, 10] | exact K.toSubmonoid | case K
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
K : Subgroup M
h : IsPretransitive (↥K) α
⊢ Submonoid M
case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
K : Subgroup M
h : IsPretransitive (↥K) α
⊢ IsPretransitive (↥?K) α | case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
K : Subgroup M
h : IsPretransitive (↥K) α
⊢ IsPretransitive (↥K.toSubmonoid) α | Please generate a tactic in lean4 to solve the state.
STATE:
case K
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
K : Subgroup M
h : IsPretransitive (↥K) α
⊢ Submonoid M
case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
K : Subgroup M
h : IsPretransitive (↥K) α
⊢ IsPretransitive (↥?K) α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isPretransitive_of_subgroup | [86, 1] | [90, 10] | exact h | case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
K : Subgroup M
h : IsPretransitive (↥K) α
⊢ IsPretransitive (↥K.toSubmonoid) α | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
K : Subgroup M
h : IsPretransitive (↥K) α
⊢ IsPretransitive (↥K.toSubmonoid) α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isPretransitive_of_subgroup_le | [93, 1] | [100, 12] | let h_eq := h.exists_smul_eq | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
G K : Subgroup M
hKG : K ≤ G
h : IsPretransitive (↥K) α
⊢ IsPretransitive (↥G) α | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
G K : Subgroup M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ IsPretransitive (↥G) α | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
G K : Subgroup M
hKG : K ≤ G
h : IsPretransitive (↥K) α
⊢ IsPretransitive (↥G) α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isPretransitive_of_subgroup_le | [93, 1] | [100, 12] | apply IsPretransitive.mk | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
G K : Subgroup M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ IsPretransitive (↥G) α | case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
G K : Subgroup M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (x y : α), ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
G K : Subgroup M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ IsPretransitive (↥G) α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isPretransitive_of_subgroup_le | [93, 1] | [100, 12] | intro x y | case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
G K : Subgroup M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (x y : α), ∃ g, g • x = y | case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
G K : Subgroup M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : α
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
G K : Subgroup M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (x y : α), ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isPretransitive_of_subgroup_le | [93, 1] | [100, 12] | obtain ⟨⟨k, hk⟩, hk'⟩ := h_eq x y | case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
G K : Subgroup M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : α
⊢ ∃ g, g • x = y | case exists_smul_eq.intro.mk
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
G K : Subgroup M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : α
k : M
hk : k ∈ K
hk' : { val := k, property := hk } • x = y
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
G K : Subgroup M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : α
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isPretransitive_of_subgroup_le | [93, 1] | [100, 12] | use ⟨k, hKG hk⟩ | case exists_smul_eq.intro.mk
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
G K : Subgroup M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : α
k : M
hk : k ∈ K
hk' : { val := k, property := hk } • x = y
⊢ ∃ g, g • x = y | case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
G K : Subgroup M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : α
k : M
hk : k ∈ K
hk' : { val := k, property := hk } • x = y
⊢ { val := k, property := ⋯ } • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq.intro.mk
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
G K : Subgroup M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : α
k : M
hk : k ∈ K
hk' : { val := k, property := hk } • x = y
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isPretransitive_of_subgroup_le | [93, 1] | [100, 12] | exact hk' | case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
G K : Subgroup M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : α
k : M
hk : k ∈ K
hk' : { val := k, property := hk } • x = y
⊢ { val := k, property := ⋯ } • x = y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
G K : Subgroup M
hKG : K ≤ G
h : IsPretransitive (↥K) α
h_eq : ∀ (x y : α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
x y : α
k : M
hk : k ∈ K
hk' : { val := k, property := hk } • x = y
⊢ { val := k, property := ⋯ } • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.finOneToMap_bijective | [126, 1] | [137, 8] | constructor | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
⊢ Function.Bijective ⇑(finOneToMap M α) | case left
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
⊢ Function.Injective ⇑(finOneToMap M α)
case right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
⊢ Function.Surjective ⇑(finOneToMap M α) | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
⊢ Function.Bijective ⇑(finOneToMap M α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.finOneToMap_bijective | [126, 1] | [137, 8] | intro x y hxy | case left
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
⊢ Function.Injective ⇑(finOneToMap M α) | case left
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
x y : Fin 1 ↪ α
hxy : (finOneToMap M α) x = (finOneToMap M α) y
⊢ x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case left
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
⊢ Function.Injective ⇑(finOneToMap M α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.finOneToMap_bijective | [126, 1] | [137, 8] | ext i | case left
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
x y : Fin 1 ↪ α
hxy : (finOneToMap M α) x = (finOneToMap M α) y
⊢ x = y | case left.h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
x y : Fin 1 ↪ α
hxy : (finOneToMap M α) x = (finOneToMap M α) y
i : Fin 1
⊢ x i = y i | Please generate a tactic in lean4 to solve the state.
STATE:
case left
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
x y : Fin 1 ↪ α
hxy : (finOneToMap M α) x = (finOneToMap M α) y
⊢ x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.finOneToMap_bijective | [126, 1] | [137, 8] | rw [Fin.eq_zero i] | case left.h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
x y : Fin 1 ↪ α
hxy : (finOneToMap M α) x = (finOneToMap M α) y
i : Fin 1
⊢ x i = y i | case left.h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
x y : Fin 1 ↪ α
hxy : (finOneToMap M α) x = (finOneToMap M α) y
i : Fin 1
⊢ x 0 = y 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case left.h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
x y : Fin 1 ↪ α
hxy : (finOneToMap M α) x = (finOneToMap M α) y
i : Fin 1
⊢ x i = y i
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.finOneToMap_bijective | [126, 1] | [137, 8] | exact hxy | case left.h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
x y : Fin 1 ↪ α
hxy : (finOneToMap M α) x = (finOneToMap M α) y
i : Fin 1
⊢ x 0 = y 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case left.h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
x y : Fin 1 ↪ α
hxy : (finOneToMap M α) x = (finOneToMap M α) y
i : Fin 1
⊢ x 0 = y 0
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.finOneToMap_bijective | [126, 1] | [137, 8] | intro a | case right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
⊢ Function.Surjective ⇑(finOneToMap M α) | case right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
⊢ ∃ a_1, (finOneToMap M α) a_1 = a | Please generate a tactic in lean4 to solve the state.
STATE:
case right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
⊢ Function.Surjective ⇑(finOneToMap M α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.finOneToMap_bijective | [126, 1] | [137, 8] | use {
toFun := fun _ => a
inj' := fun i j _ => by
rw [Fin.eq_zero i, Fin.eq_zero j] } | case right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
⊢ ∃ a_1, (finOneToMap M α) a_1 = a | case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
⊢ (finOneToMap M α) { toFun := fun x => a, inj' := ⋯ } = a | Please generate a tactic in lean4 to solve the state.
STATE:
case right
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
⊢ ∃ a_1, (finOneToMap M α) a_1 = a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.finOneToMap_bijective | [126, 1] | [137, 8] | rfl | case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
⊢ (finOneToMap M α) { toFun := fun x => a, inj' := ⋯ } = a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
⊢ (finOneToMap M α) { toFun := fun x => a, inj' := ⋯ } = a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.finOneToMap_bijective | [126, 1] | [137, 8] | rw [Fin.eq_zero i, Fin.eq_zero j] | M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
i j : Fin 1
x✝ : (fun x => a) i = (fun x => a) j
⊢ i = j | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_2
α : Type u_1
inst✝¹ : Group M
inst✝ : MulAction M α
a : α
i j : Fin 1
x✝ : (fun x => a) i = (fun x => a) j
⊢ i = j
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_subgroup | [142, 1] | [146, 38] | unfold IsMultiplyPretransitive at * | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
K : Subgroup M
h : IsMultiplyPretransitive (↥K) α n
⊢ IsMultiplyPretransitive M α n | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
K : Subgroup M
h : IsPretransitive (↥K) (Fin n ↪ α)
⊢ IsPretransitive M (Fin n ↪ α) | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
K : Subgroup M
h : IsMultiplyPretransitive (↥K) α n
⊢ IsMultiplyPretransitive M α n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_subgroup | [142, 1] | [146, 38] | exact isPretransitive_of_subgroup h | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
K : Subgroup M
h : IsPretransitive (↥K) (Fin n ↪ α)
⊢ IsPretransitive M (Fin n ↪ α) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
K : Subgroup M
h : IsPretransitive (↥K) (Fin n ↪ α)
⊢ IsPretransitive M (Fin n ↪ α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_le | [149, 1] | [152, 47] | unfold IsMultiplyPretransitive at * | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
H K : Subgroup M
hHK : K ≤ H
h : IsMultiplyPretransitive (↥K) α n
⊢ IsMultiplyPretransitive (↥H) α n | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
H K : Subgroup M
hHK : K ≤ H
h : IsPretransitive (↥K) (Fin n ↪ α)
⊢ IsPretransitive (↥H) (Fin n ↪ α) | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
H K : Subgroup M
hHK : K ≤ H
h : IsMultiplyPretransitive (↥K) α n
⊢ IsMultiplyPretransitive (↥H) α n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_le | [149, 1] | [152, 47] | refine' isPretransitive_of_subgroup_le hHK h | M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
H K : Subgroup M
hHK : K ≤ H
h : IsPretransitive (↥K) (Fin n ↪ α)
⊢ IsPretransitive (↥H) (Fin n ↪ α) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1
α : Type u_2
inst✝¹ : Group M
inst✝ : MulAction M α
n : ℕ
H K : Subgroup M
hHK : K ≤ H
h : IsPretransitive (↥K) (Fin n ↪ α)
⊢ IsPretransitive (↥H) (Fin n ↪ α)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.EquivariantMap.embeddingOfEquivariantMap_is_injective | [174, 1] | [182, 11] | intro x y hxy | M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Injective ⇑f
ι : Type u_5
⊢ Function.Injective ⇑(embeddingOfEquivariantMap hf ι) | M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Injective ⇑f
ι : Type u_5
x y : ι ↪ α
hxy : (embeddingOfEquivariantMap hf ι) x = (embeddingOfEquivariantMap hf ι) y
⊢ x = y | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Injective ⇑f
ι : Type u_5
⊢ Function.Injective ⇑(embeddingOfEquivariantMap hf ι)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.EquivariantMap.embeddingOfEquivariantMap_is_injective | [174, 1] | [182, 11] | ext i | M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Injective ⇑f
ι : Type u_5
x y : ι ↪ α
hxy : (embeddingOfEquivariantMap hf ι) x = (embeddingOfEquivariantMap hf ι) y
⊢ x = y | case h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Injective ⇑f
ι : Type u_5
x y : ι ↪ α
hxy : (embeddingOfEquivariantMap hf ι) x = (embeddingOfEquivariantMap hf ι) y
i : ι
⊢ x i = y i | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Injective ⇑f
ι : Type u_5
x y : ι ↪ α
hxy : (embeddingOfEquivariantMap hf ι) x = (embeddingOfEquivariantMap hf ι) y
⊢ x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.EquivariantMap.embeddingOfEquivariantMap_is_injective | [174, 1] | [182, 11] | apply hf | case h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Injective ⇑f
ι : Type u_5
x y : ι ↪ α
hxy : (embeddingOfEquivariantMap hf ι) x = (embeddingOfEquivariantMap hf ι) y
i : ι
⊢ x i = y i | case h.a
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Injective ⇑f
ι : Type u_5
x y : ι ↪ α
hxy : (embeddingOfEquivariantMap hf ι) x = (embeddingOfEquivariantMap hf ι) y
i : ι
⊢ f (x i) = f (y i) | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Injective ⇑f
ι : Type u_5
x y : ι ↪ α
hxy : (embeddingOfEquivariantMap hf ι) x = (embeddingOfEquivariantMap hf ι) y
i : ι
⊢ x i = y i
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.EquivariantMap.embeddingOfEquivariantMap_is_injective | [174, 1] | [182, 11] | simp only [← EquivariantMap.embeddingOfEquivariantMap_apply hf] | case h.a
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Injective ⇑f
ι : Type u_5
x y : ι ↪ α
hxy : (embeddingOfEquivariantMap hf ι) x = (embeddingOfEquivariantMap hf ι) y
i : ι
⊢ f (x i) = f (y i) | case h.a
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Injective ⇑f
ι : Type u_5
x y : ι ↪ α
hxy : (embeddingOfEquivariantMap hf ι) x = (embeddingOfEquivariantMap hf ι) y
i : ι
⊢ ((embeddingOfEquivariantMap hf ι) x) i = ((embeddingOfEquivariantMap hf ι) y) i | Please generate a tactic in lean4 to solve the state.
STATE:
case h.a
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Injective ⇑f
ι : Type u_5
x y : ι ↪ α
hxy : (embeddingOfEquivariantMap hf ι) x = (embeddingOfEquivariantMap hf ι) y
i : ι
⊢ f (x i) = f (y i)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.EquivariantMap.embeddingOfEquivariantMap_is_injective | [174, 1] | [182, 11] | rw [hxy] | case h.a
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Injective ⇑f
ι : Type u_5
x y : ι ↪ α
hxy : (embeddingOfEquivariantMap hf ι) x = (embeddingOfEquivariantMap hf ι) y
i : ι
⊢ ((embeddingOfEquivariantMap hf ι) x) i = ((embeddingOfEquivariantMap hf ι) y) i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.a
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Injective ⇑f
ι : Type u_5
x y : ι ↪ α
hxy : (embeddingOfEquivariantMap hf ι) x = (embeddingOfEquivariantMap hf ι) y
i : ι
⊢ ((embeddingOfEquivariantMap hf ι) x) i = ((embeddingOfEquivariantMap hf ι) y) i
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.EquivariantMap.embeddingOfEquivariantMap_is_bijective | [185, 1] | [196, 11] | constructor | M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
⊢ Function.Bijective ⇑(embeddingOfEquivariantMap ⋯ ι) | case left
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
⊢ Function.Injective ⇑(embeddingOfEquivariantMap ⋯ ι)
case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
⊢ Function.Surjective ⇑(embeddingOfEquivariantMap ⋯ ι) | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
⊢ Function.Bijective ⇑(embeddingOfEquivariantMap ⋯ ι)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.EquivariantMap.embeddingOfEquivariantMap_is_bijective | [185, 1] | [196, 11] | exact EquivariantMap.embeddingOfEquivariantMap_is_injective hf.injective | case left
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
⊢ Function.Injective ⇑(embeddingOfEquivariantMap ⋯ ι)
case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
⊢ Function.Surjective ⇑(embeddingOfEquivariantMap ⋯ ι) | case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
⊢ Function.Surjective ⇑(embeddingOfEquivariantMap ⋯ ι) | Please generate a tactic in lean4 to solve the state.
STATE:
case left
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
⊢ Function.Injective ⇑(embeddingOfEquivariantMap ⋯ ι)
case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
⊢ Function.Surjective ⇑(embeddingOfEquivariantMap ⋯ ι)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.EquivariantMap.embeddingOfEquivariantMap_is_bijective | [185, 1] | [196, 11] | intro y | case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
⊢ Function.Surjective ⇑(embeddingOfEquivariantMap ⋯ ι) | case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
y : ι ↪ β
⊢ ∃ a, (embeddingOfEquivariantMap ⋯ ι) a = y | Please generate a tactic in lean4 to solve the state.
STATE:
case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
⊢ Function.Surjective ⇑(embeddingOfEquivariantMap ⋯ ι)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.EquivariantMap.embeddingOfEquivariantMap_is_bijective | [185, 1] | [196, 11] | obtain ⟨g, _, hfg⟩ := Function.bijective_iff_has_inverse.mp hf | case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
y : ι ↪ β
⊢ ∃ a, (embeddingOfEquivariantMap ⋯ ι) a = y | case right.intro.intro
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
y : ι ↪ β
g : β → α
left✝ : Function.LeftInverse g ⇑f
hfg : Function.RightInverse g ⇑f
⊢ ∃ a, (embeddingOfEquivariantMap ⋯ ι) a = y | Please generate a tactic in lean4 to solve the state.
STATE:
case right
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
y : ι ↪ β
⊢ ∃ a, (embeddingOfEquivariantMap ⋯ ι) a = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.EquivariantMap.embeddingOfEquivariantMap_is_bijective | [185, 1] | [196, 11] | use ⟨g ∘ y, Function.Injective.comp hfg.injective (EmbeddingLike.injective y)⟩ | case right.intro.intro
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
y : ι ↪ β
g : β → α
left✝ : Function.LeftInverse g ⇑f
hfg : Function.RightInverse g ⇑f
⊢ ∃ a, (embeddingOfEquivariantMap ⋯ ι) a = y | case h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
y : ι ↪ β
g : β → α
left✝ : Function.LeftInverse g ⇑f
hfg : Function.RightInverse g ⇑f
⊢ (embeddingOfEquivariantMap ⋯ ι) { toFun := g ∘ ⇑y, inj' := ⋯ } = y | Please generate a tactic in lean4 to solve the state.
STATE:
case right.intro.intro
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
y : ι ↪ β
g : β → α
left✝ : Function.LeftInverse g ⇑f
hfg : Function.RightInverse g ⇑f
⊢ ∃ a, (embeddingOfEquivariantMap ⋯ ι) a = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.EquivariantMap.embeddingOfEquivariantMap_is_bijective | [185, 1] | [196, 11] | ext i | case h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
y : ι ↪ β
g : β → α
left✝ : Function.LeftInverse g ⇑f
hfg : Function.RightInverse g ⇑f
⊢ (embeddingOfEquivariantMap ⋯ ι) { toFun := g ∘ ⇑y, inj' := ⋯ } = y | case h.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
y : ι ↪ β
g : β → α
left✝ : Function.LeftInverse g ⇑f
hfg : Function.RightInverse g ⇑f
i : ι
⊢ ((embeddingOfEquivariantMap ⋯ ι) { toFun := g ∘ ⇑y, inj' := ⋯ }) i = y i | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
y : ι ↪ β
g : β → α
left✝ : Function.LeftInverse g ⇑f
hfg : Function.RightInverse g ⇑f
⊢ (embeddingOfEquivariantMap ⋯ ι) { toFun := g ∘ ⇑y, inj' := ⋯ } = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.EquivariantMap.embeddingOfEquivariantMap_is_bijective | [185, 1] | [196, 11] | rw [EquivariantMap.embeddingOfEquivariantMap_apply] | case h.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
y : ι ↪ β
g : β → α
left✝ : Function.LeftInverse g ⇑f
hfg : Function.RightInverse g ⇑f
i : ι
⊢ ((embeddingOfEquivariantMap ⋯ ι) { toFun := g ∘ ⇑y, inj' := ⋯ }) i = y i | case h.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
y : ι ↪ β
g : β → α
left✝ : Function.LeftInverse g ⇑f
hfg : Function.RightInverse g ⇑f
i : ι
⊢ f ({ toFun := g ∘ ⇑y, inj' := ⋯ } i) = y i | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
y : ι ↪ β
g : β → α
left✝ : Function.LeftInverse g ⇑f
hfg : Function.RightInverse g ⇑f
i : ι
⊢ ((embeddingOfEquivariantMap ⋯ ι) { toFun := g ∘ ⇑y, inj' := ⋯ }) i = y i
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.EquivariantMap.embeddingOfEquivariantMap_is_bijective | [185, 1] | [196, 11] | simp only [coeFn_mk, Function.comp_apply] | case h.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
y : ι ↪ β
g : β → α
left✝ : Function.LeftInverse g ⇑f
hfg : Function.RightInverse g ⇑f
i : ι
⊢ f ({ toFun := g ∘ ⇑y, inj' := ⋯ } i) = y i | case h.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
y : ι ↪ β
g : β → α
left✝ : Function.LeftInverse g ⇑f
hfg : Function.RightInverse g ⇑f
i : ι
⊢ f (g (y i)) = y i | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
y : ι ↪ β
g : β → α
left✝ : Function.LeftInverse g ⇑f
hfg : Function.RightInverse g ⇑f
i : ι
⊢ f ({ toFun := g ∘ ⇑y, inj' := ⋯ } i) = y i
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.EquivariantMap.embeddingOfEquivariantMap_is_bijective | [185, 1] | [196, 11] | rw [hfg] | case h.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
y : ι ↪ β
g : β → α
left✝ : Function.LeftInverse g ⇑f
hfg : Function.RightInverse g ⇑f
i : ι
⊢ f (g (y i)) = y i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
σ : M → N
f : α →ₑ[σ] β
hf : Function.Bijective ⇑f
ι : Type u_5
y : ι ↪ β
g : β → α
left✝ : Function.LeftInverse g ⇑f
hfg : Function.RightInverse g ⇑f
i : ι
⊢ f (g (y i)) = y i
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_surjective_map | [200, 1] | [223, 68] | let h_eq := h.exists_smul_eq | M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
⊢ IsMultiplyPretransitive N β n | M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ IsMultiplyPretransitive N β n | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
⊢ IsMultiplyPretransitive N β n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_surjective_map | [200, 1] | [223, 68] | apply IsPretransitive.mk | M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ IsMultiplyPretransitive N β n | case exists_smul_eq
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (x y : Fin n ↪ β), ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ IsMultiplyPretransitive N β n
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_surjective_map | [200, 1] | [223, 68] | let aux : (Fin n ↪ β) → (Fin n ↪ α) := fun x =>
{ toFun := (Function.surjInv hf) ∘ x.toFun
inj' := fun u v huv => by
let huv' :=congr_arg f huv
simp only [Function.comp_apply, Function.surjInv_eq] at huv'
exact x.inj' huv' } | case exists_smul_eq
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (x y : Fin n ↪ β), ∃ g, g • x = y | case exists_smul_eq
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
⊢ ∀ (x y : Fin n ↪ β), ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
⊢ ∀ (x y : Fin n ↪ β), ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_surjective_map | [200, 1] | [223, 68] | have aux_apply : ∀ (x : Fin n ↪ β) (i : Fin n), f.toFun (aux x i) = x i := fun x i => by
simp only [toFun_eq_coe, coeFn_mk, Function.comp_apply, aux]
apply Function.surjInv_eq | case exists_smul_eq
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
⊢ ∀ (x y : Fin n ↪ β), ∃ g, g • x = y | case exists_smul_eq
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
aux_apply : ∀ (x : Fin n ↪ β) (i : Fin n), f.toFun ((aux x) i) = x i
⊢ ∀ (x y : Fin n ↪ β), ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
⊢ ∀ (x y : Fin n ↪ β), ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_surjective_map | [200, 1] | [223, 68] | intro x y | case exists_smul_eq
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
aux_apply : ∀ (x : Fin n ↪ β) (i : Fin n), f.toFun ((aux x) i) = x i
⊢ ∀ (x y : Fin n ↪ β), ∃ g, g • x = y | case exists_smul_eq
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
aux_apply : ∀ (x : Fin n ↪ β) (i : Fin n), f.toFun ((aux x) i) = x i
x y : Fin n ↪ β
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
aux_apply : ∀ (x : Fin n ↪ β) (i : Fin n), f.toFun ((aux x) i) = x i
⊢ ∀ (x y : Fin n ↪ β), ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_surjective_map | [200, 1] | [223, 68] | obtain ⟨g, hg⟩ := h_eq (aux x) (aux y) | case exists_smul_eq
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
aux_apply : ∀ (x : Fin n ↪ β) (i : Fin n), f.toFun ((aux x) i) = x i
x y : Fin n ↪ β
⊢ ∃ g, g • x = y | case exists_smul_eq.intro
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
aux_apply : ∀ (x : Fin n ↪ β) (i : Fin n), f.toFun ((aux x) i) = x i
x y : Fin n ↪ β
g : M
hg : g • aux x = aux y
⊢ ∃ g, g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
aux_apply : ∀ (x : Fin n ↪ β) (i : Fin n), f.toFun ((aux x) i) = x i
x y : Fin n ↪ β
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_surjective_map | [200, 1] | [223, 68] | use σ g | case exists_smul_eq.intro
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
aux_apply : ∀ (x : Fin n ↪ β) (i : Fin n), f.toFun ((aux x) i) = x i
x y : Fin n ↪ β
g : M
hg : g • aux x = aux y
⊢ ∃ g, g • x = y | case h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
aux_apply : ∀ (x : Fin n ↪ β) (i : Fin n), f.toFun ((aux x) i) = x i
x y : Fin n ↪ β
g : M
hg : g • aux x = aux y
⊢ σ g • x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case exists_smul_eq.intro
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
aux_apply : ∀ (x : Fin n ↪ β) (i : Fin n), f.toFun ((aux x) i) = x i
x y : Fin n ↪ β
g : M
hg : g • aux x = aux y
⊢ ∃ g, g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_surjective_map | [200, 1] | [223, 68] | ext i | case h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
aux_apply : ∀ (x : Fin n ↪ β) (i : Fin n), f.toFun ((aux x) i) = x i
x y : Fin n ↪ β
g : M
hg : g • aux x = aux y
⊢ σ g • x = y | case h.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
aux_apply : ∀ (x : Fin n ↪ β) (i : Fin n), f.toFun ((aux x) i) = x i
x y : Fin n ↪ β
g : M
hg : g • aux x = aux y
i : Fin n
⊢ (σ g • x) i = y i | Please generate a tactic in lean4 to solve the state.
STATE:
case h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
aux_apply : ∀ (x : Fin n ↪ β) (i : Fin n), f.toFun ((aux x) i) = x i
x y : Fin n ↪ β
g : M
hg : g • aux x = aux y
⊢ σ g • x = y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_surjective_map | [200, 1] | [223, 68] | rw [DFunLike.ext_iff] at hg | case h.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
aux_apply : ∀ (x : Fin n ↪ β) (i : Fin n), f.toFun ((aux x) i) = x i
x y : Fin n ↪ β
g : M
hg : g • aux x = aux y
i : Fin n
⊢ (σ g • x) i = y i | case h.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
aux_apply : ∀ (x : Fin n ↪ β) (i : Fin n), f.toFun ((aux x) i) = x i
x y : Fin n ↪ β
g : M
hg : ∀ (x_1 : Fin n), (g • aux x) x_1 = (aux y) x_1
i : Fin n
⊢ (σ g • x) i = y i | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
aux_apply : ∀ (x : Fin n ↪ β) (i : Fin n), f.toFun ((aux x) i) = x i
x y : Fin n ↪ β
g : M
hg : g • aux x = aux y
i : Fin n
⊢ (σ g • x) i = y i
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/MultipleTransitivity.lean | MulAction.isMultiplyPretransitive_of_surjective_map | [200, 1] | [223, 68] | simp only [smul_apply] | case h.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
aux_apply : ∀ (x : Fin n ↪ β) (i : Fin n), f.toFun ((aux x) i) = x i
x y : Fin n ↪ β
g : M
hg : ∀ (x_1 : Fin n), (g • aux x) x_1 = (aux y) x_1
i : Fin n
⊢ (σ g • x) i = y i | case h.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
aux_apply : ∀ (x : Fin n ↪ β) (i : Fin n), f.toFun ((aux x) i) = x i
x y : Fin n ↪ β
g : M
hg : ∀ (x_1 : Fin n), (g • aux x) x_1 = (aux y) x_1
i : Fin n
⊢ σ g • x i = y i | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h
M : Type u_4
α : Type u_3
inst✝³ : Group M
inst✝² : MulAction M α
N : Type u_1
β : Type u_2
inst✝¹ : Group N
inst✝ : MulAction N β
n : ℕ
σ : M → N
f : α →ₑ[σ] β
hf : Function.Surjective ⇑f
h : IsMultiplyPretransitive M α n
h_eq : ∀ (x y : Fin n ↪ α), ∃ g, g • x = y := IsPretransitive.exists_smul_eq
aux : (Fin n ↪ β) → Fin n ↪ α := fun x => { toFun := Function.surjInv hf ∘ x.toFun, inj' := ⋯ }
aux_apply : ∀ (x : Fin n ↪ β) (i : Fin n), f.toFun ((aux x) i) = x i
x y : Fin n ↪ β
g : M
hg : ∀ (x_1 : Fin n), (g • aux x) x_1 = (aux y) x_1
i : Fin n
⊢ (σ g • x) i = y i
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.