pkuAI4M/lean_github · Datasets at Hugging Face

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/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_updateIte	[551, 1]	[581, 20]	simp only [Function.updateITE]	α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ⊢ updateITE f y z x = f x	α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ⊢ (if x = y then z else f x) = f x	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ⊢ updateITE f y z x = f x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_updateIte	[551, 1]	[581, 20]	simp only [if_neg h1]	α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ⊢ (if x = y then z else f x) = f x	no goals	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ⊢ (if x = y then z else f x) = f x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_updateIte	[551, 1]	[581, 20]	simp only [Function.updateListITE]	α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β ⊢ updateListITE (updateITE f y z) (xs_hd :: xs_tl) (ys_hd :: ys_tl) x = updateListITE f (xs_hd :: xs_tl) (ys_hd :: ys_tl) x	α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β ⊢ updateITE (updateListITE (updateITE f y z) xs_tl ys_tl) xs_hd ys_hd x = updateITE (updateListITE f xs_tl ys_tl) xs_hd ys_hd x	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β ⊢ updateListITE (updateITE f y z) (xs_hd :: xs_tl) (ys_hd :: ys_tl) x = updateListITE f (xs_hd :: xs_tl) (ys_hd :: ys_tl) x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_updateIte	[551, 1]	[581, 20]	simp only [Function.updateITE]	α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β ⊢ updateITE (updateListITE (updateITE f y z) xs_tl ys_tl) xs_hd ys_hd x = updateITE (updateListITE f xs_tl ys_tl) xs_hd ys_hd x	α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β ⊢ (if x = xs_hd then ys_hd else updateListITE (updateITE f y z) xs_tl ys_tl x) = if x = xs_hd then ys_hd else updateListITE f xs_tl ys_tl x	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β ⊢ updateITE (updateListITE (updateITE f y z) xs_tl ys_tl) xs_hd ys_hd x = updateITE (updateListITE f xs_tl ys_tl) xs_hd ys_hd x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_updateIte	[551, 1]	[581, 20]	split_ifs	α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β ⊢ (if x = xs_hd then ys_hd else updateListITE (updateITE f y z) xs_tl ys_tl x) = if x = xs_hd then ys_hd else updateListITE f xs_tl ys_tl x	case pos α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β h✝ : x = xs_hd ⊢ ys_hd = ys_hd case neg α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β h✝ : ¬x = xs_hd ⊢ updateListITE (updateITE f y z) xs_tl ys_tl x = updateListITE f xs_tl ys_tl x	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β ⊢ (if x = xs_hd then ys_hd else updateListITE (updateITE f y z) xs_tl ys_tl x) = if x = xs_hd then ys_hd else updateListITE f xs_tl ys_tl x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_updateIte	[551, 1]	[581, 20]	case pos c1 => rfl	α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β c1 : x = xs_hd ⊢ ys_hd = ys_hd	no goals	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β c1 : x = xs_hd ⊢ ys_hd = ys_hd TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_updateIte	[551, 1]	[581, 20]	case neg c1 => apply xs_ih	α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β c1 : ¬x = xs_hd ⊢ updateListITE (updateITE f y z) xs_tl ys_tl x = updateListITE f xs_tl ys_tl x	no goals	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β c1 : ¬x = xs_hd ⊢ updateListITE (updateITE f y z) xs_tl ys_tl x = updateListITE f xs_tl ys_tl x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_updateIte	[551, 1]	[581, 20]	rfl	α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β c1 : x = xs_hd ⊢ ys_hd = ys_hd	no goals	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β c1 : x = xs_hd ⊢ ys_hd = ys_hd TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_updateIte	[551, 1]	[581, 20]	apply xs_ih	α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β c1 : ¬x = xs_hd ⊢ updateListITE (updateITE f y z) xs_tl ys_tl x = updateListITE f xs_tl ys_tl x	no goals	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β c1 : ¬x = xs_hd ⊢ updateListITE (updateITE f y z) xs_tl ys_tl x = updateListITE f xs_tl ys_tl x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_fun_coincide_mem_eq_len	[584, 1]	[604, 13]	have s1 : List.map f ys = List.map g ys	α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map g ys) x	case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length ⊢ List.map f ys = List.map g ys α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map g ys) x	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map g ys) x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_fun_coincide_mem_eq_len	[584, 1]	[604, 13]	simp only [List.map_eq_map_iff]	case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length ⊢ List.map f ys = List.map g ys α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map g ys) x	case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length ⊢ ∀ x ∈ ys, f x = g x α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map g ys) x	Please generate a tactic in lean4 to solve the state. STATE: case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length ⊢ List.map f ys = List.map g ys α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map g ys) x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_fun_coincide_mem_eq_len	[584, 1]	[604, 13]	exact h1	case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length ⊢ ∀ x ∈ ys, f x = g x α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map g ys) x	α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map g ys) x	Please generate a tactic in lean4 to solve the state. STATE: case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length ⊢ ∀ x ∈ ys, f x = g x α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map g ys) x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_fun_coincide_mem_eq_len	[584, 1]	[604, 13]	simp only [s1]	α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map g ys) x	α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ updateListITE f xs (List.map g ys) x = updateListITE g xs (List.map g ys) x	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map g ys) x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_fun_coincide_mem_eq_len	[584, 1]	[604, 13]	apply Function.updateListITE_mem_eq_len	α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ updateListITE f xs (List.map g ys) x = updateListITE g xs (List.map g ys) x	case h1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ x ∈ xs case h2 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ xs.length = (List.map g ys).length	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ updateListITE f xs (List.map g ys) x = updateListITE g xs (List.map g ys) x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_fun_coincide_mem_eq_len	[584, 1]	[604, 13]	exact h2	case h1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ x ∈ xs	no goals	Please generate a tactic in lean4 to solve the state. STATE: case h1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ x ∈ xs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_fun_coincide_mem_eq_len	[584, 1]	[604, 13]	simp	case h2 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ xs.length = (List.map g ys).length	case h2 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ xs.length = ys.length	Please generate a tactic in lean4 to solve the state. STATE: case h2 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ xs.length = (List.map g ys).length TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_fun_coincide_mem_eq_len	[584, 1]	[604, 13]	exact h3	case h2 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ xs.length = ys.length	no goals	Please generate a tactic in lean4 to solve the state. STATE: case h2 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ xs.length = ys.length TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_mem_ext	[607, 1]	[627, 13]	have s1 : List.map h ys = List.map h' ys	α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs ⊢ updateListITE f xs (List.map h ys) x = updateListITE g xs (List.map h' ys) x	case s1 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs ⊢ List.map h ys = List.map h' ys α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ updateListITE f xs (List.map h ys) x = updateListITE g xs (List.map h' ys) x	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs ⊢ updateListITE f xs (List.map h ys) x = updateListITE g xs (List.map h' ys) x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_mem_ext	[607, 1]	[627, 13]	simp only [List.map_eq_map_iff]	case s1 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs ⊢ List.map h ys = List.map h' ys α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ updateListITE f xs (List.map h ys) x = updateListITE g xs (List.map h' ys) x	case s1 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs ⊢ ∀ x ∈ ys, h x = h' x α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ updateListITE f xs (List.map h ys) x = updateListITE g xs (List.map h' ys) x	Please generate a tactic in lean4 to solve the state. STATE: case s1 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs ⊢ List.map h ys = List.map h' ys α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ updateListITE f xs (List.map h ys) x = updateListITE g xs (List.map h' ys) x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_mem_ext	[607, 1]	[627, 13]	exact h1	case s1 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs ⊢ ∀ x ∈ ys, h x = h' x α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ updateListITE f xs (List.map h ys) x = updateListITE g xs (List.map h' ys) x	α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ updateListITE f xs (List.map h ys) x = updateListITE g xs (List.map h' ys) x	Please generate a tactic in lean4 to solve the state. STATE: case s1 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs ⊢ ∀ x ∈ ys, h x = h' x α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ updateListITE f xs (List.map h ys) x = updateListITE g xs (List.map h' ys) x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_mem_ext	[607, 1]	[627, 13]	simp only [s1]	α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ updateListITE f xs (List.map h ys) x = updateListITE g xs (List.map h' ys) x	α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ updateListITE f xs (List.map h' ys) x = updateListITE g xs (List.map h' ys) x	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ updateListITE f xs (List.map h ys) x = updateListITE g xs (List.map h' ys) x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_mem_ext	[607, 1]	[627, 13]	apply Function.updateListITE_mem_eq_len	α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ updateListITE f xs (List.map h' ys) x = updateListITE g xs (List.map h' ys) x	case h1 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ x ∈ xs case h2 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ xs.length = (List.map h' ys).length	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ updateListITE f xs (List.map h' ys) x = updateListITE g xs (List.map h' ys) x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_mem_ext	[607, 1]	[627, 13]	exact h3	case h1 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ x ∈ xs	no goals	Please generate a tactic in lean4 to solve the state. STATE: case h1 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ x ∈ xs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_mem_ext	[607, 1]	[627, 13]	simp	case h2 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ xs.length = (List.map h' ys).length	case h2 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ xs.length = ys.length	Please generate a tactic in lean4 to solve the state. STATE: case h2 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ xs.length = (List.map h' ys).length TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_mem_ext	[607, 1]	[627, 13]	exact h2	case h2 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ xs.length = ys.length	no goals	Please generate a tactic in lean4 to solve the state. STATE: case h2 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ xs.length = ys.length TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_mem	[630, 1]	[653, 12]	induction xs	α β : Type inst✝ : DecidableEq α f g : α → β xs : List α x : α h1 : x ∈ xs ⊢ updateListITE f xs (List.map g xs) x = g x	case nil α β : Type inst✝ : DecidableEq α f g : α → β x : α h1 : x ∈ [] ⊢ updateListITE f [] (List.map g []) x = g x case cons α β : Type inst✝ : DecidableEq α f g : α → β x head✝ : α tail✝ : List α tail_ih✝ : x ∈ tail✝ → updateListITE f tail✝ (List.map g tail✝) x = g x h1 : x ∈ head✝ :: tail✝ ⊢ updateListITE f (head✝ :: tail✝) (List.map g (head✝ :: tail✝)) x = g x	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β xs : List α x : α h1 : x ∈ xs ⊢ updateListITE f xs (List.map g xs) x = g x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_mem	[630, 1]	[653, 12]	case nil => simp at h1	α β : Type inst✝ : DecidableEq α f g : α → β x : α h1 : x ∈ [] ⊢ updateListITE f [] (List.map g []) x = g x	no goals	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x : α h1 : x ∈ [] ⊢ updateListITE f [] (List.map g []) x = g x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_mem	[630, 1]	[653, 12]	case cons hd tl ih => simp at h1 simp simp only [Function.updateListITE] simp only [Function.updateITE] split_ifs case _ c1 => subst c1 rfl case _ c1 => tauto	α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x ∈ hd :: tl ⊢ updateListITE f (hd :: tl) (List.map g (hd :: tl)) x = g x	no goals	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x ∈ hd :: tl ⊢ updateListITE f (hd :: tl) (List.map g (hd :: tl)) x = g x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_mem	[630, 1]	[653, 12]	simp at h1	α β : Type inst✝ : DecidableEq α f g : α → β x : α h1 : x ∈ [] ⊢ updateListITE f [] (List.map g []) x = g x	no goals	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x : α h1 : x ∈ [] ⊢ updateListITE f [] (List.map g []) x = g x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_mem	[630, 1]	[653, 12]	simp at h1	α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x ∈ hd :: tl ⊢ updateListITE f (hd :: tl) (List.map g (hd :: tl)) x = g x	α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl ⊢ updateListITE f (hd :: tl) (List.map g (hd :: tl)) x = g x	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x ∈ hd :: tl ⊢ updateListITE f (hd :: tl) (List.map g (hd :: tl)) x = g x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_mem	[630, 1]	[653, 12]	simp	α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl ⊢ updateListITE f (hd :: tl) (List.map g (hd :: tl)) x = g x	α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl ⊢ updateListITE f (hd :: tl) (g hd :: List.map g tl) x = g x	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl ⊢ updateListITE f (hd :: tl) (List.map g (hd :: tl)) x = g x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_mem	[630, 1]	[653, 12]	simp only [Function.updateListITE]	α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl ⊢ updateListITE f (hd :: tl) (g hd :: List.map g tl) x = g x	α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl ⊢ updateITE (updateListITE f tl (List.map g tl)) hd (g hd) x = g x	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl ⊢ updateListITE f (hd :: tl) (g hd :: List.map g tl) x = g x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_mem	[630, 1]	[653, 12]	simp only [Function.updateITE]	α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl ⊢ updateITE (updateListITE f tl (List.map g tl)) hd (g hd) x = g x	α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl ⊢ (if x = hd then g hd else updateListITE f tl (List.map g tl) x) = g x	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl ⊢ updateITE (updateListITE f tl (List.map g tl)) hd (g hd) x = g x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_mem	[630, 1]	[653, 12]	split_ifs	α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl ⊢ (if x = hd then g hd else updateListITE f tl (List.map g tl) x) = g x	case pos α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl h✝ : x = hd ⊢ g hd = g x case neg α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl h✝ : ¬x = hd ⊢ updateListITE f tl (List.map g tl) x = g x	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl ⊢ (if x = hd then g hd else updateListITE f tl (List.map g tl) x) = g x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_mem	[630, 1]	[653, 12]	case _ c1 => subst c1 rfl	α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl c1 : x = hd ⊢ g hd = g x	no goals	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl c1 : x = hd ⊢ g hd = g x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_mem	[630, 1]	[653, 12]	case _ c1 => tauto	α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl c1 : ¬x = hd ⊢ updateListITE f tl (List.map g tl) x = g x	no goals	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl c1 : ¬x = hd ⊢ updateListITE f tl (List.map g tl) x = g x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_mem	[630, 1]	[653, 12]	subst c1	α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl c1 : x = hd ⊢ g hd = g x	α β : Type inst✝ : DecidableEq α f g : α → β x : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = x ∨ x ∈ tl ⊢ g x = g x	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl c1 : x = hd ⊢ g hd = g x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_mem	[630, 1]	[653, 12]	rfl	α β : Type inst✝ : DecidableEq α f g : α → β x : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = x ∨ x ∈ tl ⊢ g x = g x	no goals	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = x ∨ x ∈ tl ⊢ g x = g x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_mem	[630, 1]	[653, 12]	tauto	α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl c1 : ¬x = hd ⊢ updateListITE f tl (List.map g tl) x = g x	no goals	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl c1 : ¬x = hd ⊢ updateListITE f tl (List.map g tl) x = g x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_updateIte	[656, 1]	[680, 93]	have s1 : ∀ (y : α), y ∈ ys → f y =Function.updateITE f v a y	α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x	case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs ⊢ ∀ y ∈ ys, f y = updateITE f v a y α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs s1 : ∀ y ∈ ys, f y = updateITE f v a y ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_updateIte	[656, 1]	[680, 93]	intro y a1	case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs ⊢ ∀ y ∈ ys, f y = updateITE f v a y α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs s1 : ∀ y ∈ ys, f y = updateITE f v a y ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x	case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys ⊢ f y = updateITE f v a y α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs s1 : ∀ y ∈ ys, f y = updateITE f v a y ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x	Please generate a tactic in lean4 to solve the state. STATE: case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs ⊢ ∀ y ∈ ys, f y = updateITE f v a y α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs s1 : ∀ y ∈ ys, f y = updateITE f v a y ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_updateIte	[656, 1]	[680, 93]	simp only [Function.updateITE]	case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys ⊢ f y = updateITE f v a y α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs s1 : ∀ y ∈ ys, f y = updateITE f v a y ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x	case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys ⊢ f y = if y = v then a else f y α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs s1 : ∀ y ∈ ys, f y = updateITE f v a y ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x	Please generate a tactic in lean4 to solve the state. STATE: case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys ⊢ f y = updateITE f v a y α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs s1 : ∀ y ∈ ys, f y = updateITE f v a y ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_updateIte	[656, 1]	[680, 93]	split_ifs	case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys ⊢ f y = if y = v then a else f y α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs s1 : ∀ y ∈ ys, f y = updateITE f v a y ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x	case pos α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys h✝ : y = v ⊢ f y = a case neg α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys h✝ : ¬y = v ⊢ f y = f y α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs s1 : ∀ y ∈ ys, f y = updateITE f v a y ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x	Please generate a tactic in lean4 to solve the state. STATE: case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys ⊢ f y = if y = v then a else f y α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs s1 : ∀ y ∈ ys, f y = updateITE f v a y ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_updateIte	[656, 1]	[680, 93]	case _ c1 => specialize h1 y a1 contradiction	α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys c1 : y = v ⊢ f y = a	no goals	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys c1 : y = v ⊢ f y = a TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_updateIte	[656, 1]	[680, 93]	case _ c2 => rfl	α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys c2 : ¬y = v ⊢ f y = f y	no goals	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys c2 : ¬y = v ⊢ f y = f y TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_updateIte	[656, 1]	[680, 93]	exact Function.updateListITE_map_mem_ext xs ys f g f (Function.updateITE f v a) x s1 h2 h3	α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs s1 : ∀ y ∈ ys, f y = updateITE f v a y ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x	no goals	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs s1 : ∀ y ∈ ys, f y = updateITE f v a y ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_updateIte	[656, 1]	[680, 93]	specialize h1 y a1	α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys c1 : y = v ⊢ f y = a	α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys c1 : y = v h1 : ¬y = v ⊢ f y = a	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys c1 : y = v ⊢ f y = a TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_updateIte	[656, 1]	[680, 93]	contradiction	α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys c1 : y = v h1 : ¬y = v ⊢ f y = a	no goals	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys c1 : y = v h1 : ¬y = v ⊢ f y = a TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/FunctionUpdateITE.lean	Function.updateListITE_map_updateIte	[656, 1]	[680, 93]	rfl	α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys c2 : ¬y = v ⊢ f y = f y	no goals	Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys c2 : ¬y = v ⊢ f y = f y TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	ext cs	α : Type R : RegExp α ⊢ RegExp.languageOf α R.closure = RegExp.languageOf α (RegExp.epsilon.union (R.concat R.closure))	case h α : Type R : RegExp α cs : List α ⊢ cs ∈ RegExp.languageOf α R.closure ↔ cs ∈ RegExp.languageOf α (RegExp.epsilon.union (R.concat R.closure))	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α ⊢ RegExp.languageOf α R.closure = RegExp.languageOf α (RegExp.epsilon.union (R.concat R.closure)) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	simp only [RegExp.languageOf]	case h α : Type R : RegExp α cs : List α ⊢ cs ∈ RegExp.languageOf α R.closure ↔ cs ∈ RegExp.languageOf α (RegExp.epsilon.union (R.concat R.closure))	case h α : Type R : RegExp α cs : List α ⊢ cs ∈ {l \| ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = l} ↔ cs ∈ {[]} ∪ {x \| ∃ r ∈ RegExp.languageOf α R, ∃ s ∈ {l \| ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = l}, r ++ s = x}	Please generate a tactic in lean4 to solve the state. STATE: case h α : Type R : RegExp α cs : List α ⊢ cs ∈ RegExp.languageOf α R.closure ↔ cs ∈ RegExp.languageOf α (RegExp.epsilon.union (R.concat R.closure)) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	simp	case h α : Type R : RegExp α cs : List α ⊢ cs ∈ {l \| ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = l} ↔ cs ∈ {[]} ∪ {x \| ∃ r ∈ RegExp.languageOf α R, ∃ s ∈ {l \| ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = l}, r ++ s = x}	case h α : Type R : RegExp α cs : List α ⊢ (∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs) ↔ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs	Please generate a tactic in lean4 to solve the state. STATE: case h α : Type R : RegExp α cs : List α ⊢ cs ∈ {l \| ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = l} ↔ cs ∈ {[]} ∪ {x \| ∃ r ∈ RegExp.languageOf α R, ∃ s ∈ {l \| ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = l}, r ++ s = x} TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	constructor	case h α : Type R : RegExp α cs : List α ⊢ (∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs) ↔ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs	case h.mp α : Type R : RegExp α cs : List α ⊢ (∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs) → cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs case h.mpr α : Type R : RegExp α cs : List α ⊢ (cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs) → ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	Please generate a tactic in lean4 to solve the state. STATE: case h α : Type R : RegExp α cs : List α ⊢ (∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs) ↔ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	intro a1	case h.mp α : Type R : RegExp α cs : List α ⊢ (∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs) → cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs	case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs	Please generate a tactic in lean4 to solve the state. STATE: case h.mp α : Type R : RegExp α cs : List α ⊢ (∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs) → cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	apply Exists.elim a1	case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs	case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs ⊢ ∀ (a : List (List α)), (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ a.join = cs → cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs	Please generate a tactic in lean4 to solve the state. STATE: case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	intro xs a2	case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs ⊢ ∀ (a : List (List α)), (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ a.join = cs → cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs	case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs xs : List (List α) a2 : (∀ r ∈ xs, r ∈ RegExp.languageOf α R) ∧ xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs	Please generate a tactic in lean4 to solve the state. STATE: case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs ⊢ ∀ (a : List (List α)), (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ a.join = cs → cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	clear a1	case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs xs : List (List α) a2 : (∀ r ∈ xs, r ∈ RegExp.languageOf α R) ∧ xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs	case h.mp α : Type R : RegExp α cs : List α xs : List (List α) a2 : (∀ r ∈ xs, r ∈ RegExp.languageOf α R) ∧ xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs	Please generate a tactic in lean4 to solve the state. STATE: case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs xs : List (List α) a2 : (∀ r ∈ xs, r ∈ RegExp.languageOf α R) ∧ xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	cases a2	case h.mp α : Type R : RegExp α cs : List α xs : List (List α) a2 : (∀ r ∈ xs, r ∈ RegExp.languageOf α R) ∧ xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs	case h.mp.intro α : Type R : RegExp α cs : List α xs : List (List α) left✝ : ∀ r ∈ xs, r ∈ RegExp.languageOf α R right✝ : xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs	Please generate a tactic in lean4 to solve the state. STATE: case h.mp α : Type R : RegExp α cs : List α xs : List (List α) a2 : (∀ r ∈ xs, r ∈ RegExp.languageOf α R) ∧ xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	case _ a2_left a2_right => simp only [← a2_right] cases xs case nil => left simp case cons hd tl => right simp at a2_left cases a2_left case _ a2_left_left a2_left_right => apply Exists.intro hd tauto	α : Type R : RegExp α cs : List α xs : List (List α) a2_left : ∀ r ∈ xs, r ∈ RegExp.languageOf α R a2_right : xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs	no goals	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α xs : List (List α) a2_left : ∀ r ∈ xs, r ∈ RegExp.languageOf α R a2_right : xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	simp only [← a2_right]	α : Type R : RegExp α cs : List α xs : List (List α) a2_left : ∀ r ∈ xs, r ∈ RegExp.languageOf α R a2_right : xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs	α : Type R : RegExp α cs : List α xs : List (List α) a2_left : ∀ r ∈ xs, r ∈ RegExp.languageOf α R a2_right : xs.join = cs ⊢ xs.join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = xs.join	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α xs : List (List α) a2_left : ∀ r ∈ xs, r ∈ RegExp.languageOf α R a2_right : xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	cases xs	α : Type R : RegExp α cs : List α xs : List (List α) a2_left : ∀ r ∈ xs, r ∈ RegExp.languageOf α R a2_right : xs.join = cs ⊢ xs.join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = xs.join	case nil α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = [].join case cons α : Type R : RegExp α cs head✝ : List α tail✝ : List (List α) a2_left : ∀ r ∈ head✝ :: tail✝, r ∈ RegExp.languageOf α R a2_right : (head✝ :: tail✝).join = cs ⊢ (head✝ :: tail✝).join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (head✝ :: tail✝).join	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α xs : List (List α) a2_left : ∀ r ∈ xs, r ∈ RegExp.languageOf α R a2_right : xs.join = cs ⊢ xs.join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = xs.join TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	case nil => left simp	α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = [].join	no goals	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = [].join TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	case cons hd tl => right simp at a2_left cases a2_left case _ a2_left_left a2_left_right => apply Exists.intro hd tauto	α : Type R : RegExp α cs hd : List α tl : List (List α) a2_left : ∀ r ∈ hd :: tl, r ∈ RegExp.languageOf α R a2_right : (hd :: tl).join = cs ⊢ (hd :: tl).join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join	no goals	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs hd : List α tl : List (List α) a2_left : ∀ r ∈ hd :: tl, r ∈ RegExp.languageOf α R a2_right : (hd :: tl).join = cs ⊢ (hd :: tl).join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	left	α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = [].join	case h α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = []	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = [].join TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	simp	case h α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = []	no goals	Please generate a tactic in lean4 to solve the state. STATE: case h α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = [] TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	right	α : Type R : RegExp α cs hd : List α tl : List (List α) a2_left : ∀ r ∈ hd :: tl, r ∈ RegExp.languageOf α R a2_right : (hd :: tl).join = cs ⊢ (hd :: tl).join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join	case h α : Type R : RegExp α cs hd : List α tl : List (List α) a2_left : ∀ r ∈ hd :: tl, r ∈ RegExp.languageOf α R a2_right : (hd :: tl).join = cs ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs hd : List α tl : List (List α) a2_left : ∀ r ∈ hd :: tl, r ∈ RegExp.languageOf α R a2_right : (hd :: tl).join = cs ⊢ (hd :: tl).join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	simp at a2_left	case h α : Type R : RegExp α cs hd : List α tl : List (List α) a2_left : ∀ r ∈ hd :: tl, r ∈ RegExp.languageOf α R a2_right : (hd :: tl).join = cs ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join	case h α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left : hd ∈ RegExp.languageOf α R ∧ ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join	Please generate a tactic in lean4 to solve the state. STATE: case h α : Type R : RegExp α cs hd : List α tl : List (List α) a2_left : ∀ r ∈ hd :: tl, r ∈ RegExp.languageOf α R a2_right : (hd :: tl).join = cs ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	cases a2_left	case h α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left : hd ∈ RegExp.languageOf α R ∧ ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join	case h.intro α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs left✝ : hd ∈ RegExp.languageOf α R right✝ : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join	Please generate a tactic in lean4 to solve the state. STATE: case h α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left : hd ∈ RegExp.languageOf α R ∧ ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	case _ a2_left_left a2_left_right => apply Exists.intro hd tauto	α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left_left : hd ∈ RegExp.languageOf α R a2_left_right : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join	no goals	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left_left : hd ∈ RegExp.languageOf α R a2_left_right : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	apply Exists.intro hd	α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left_left : hd ∈ RegExp.languageOf α R a2_left_right : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join	α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left_left : hd ∈ RegExp.languageOf α R a2_left_right : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ hd ∈ RegExp.languageOf α R ∧ ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ hd ++ a.join = (hd :: tl).join	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left_left : hd ∈ RegExp.languageOf α R a2_left_right : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	tauto	α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left_left : hd ∈ RegExp.languageOf α R a2_left_right : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ hd ∈ RegExp.languageOf α R ∧ ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ hd ++ a.join = (hd :: tl).join	no goals	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left_left : hd ∈ RegExp.languageOf α R a2_left_right : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ hd ∈ RegExp.languageOf α R ∧ ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ hd ++ a.join = (hd :: tl).join TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	intro a1	case h.mpr α : Type R : RegExp α cs : List α ⊢ (cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs) → ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	case h.mpr α : Type R : RegExp α cs : List α a1 : cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	Please generate a tactic in lean4 to solve the state. STATE: case h.mpr α : Type R : RegExp α cs : List α ⊢ (cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs) → ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	cases a1	case h.mpr α : Type R : RegExp α cs : List α a1 : cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	case h.mpr.inl α : Type R : RegExp α cs : List α h✝ : cs = [] ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs case h.mpr.inr α : Type R : RegExp α cs : List α h✝ : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	Please generate a tactic in lean4 to solve the state. STATE: case h.mpr α : Type R : RegExp α cs : List α a1 : cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	case _ left => apply Exists.intro [] simp simp only [left]	α : Type R : RegExp α cs : List α left : cs = [] ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	no goals	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α left : cs = [] ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	case _ right => apply Exists.elim right intro xs a2 clear right cases a2 case _ a2_left a2_right => apply Exists.elim a2_right intro ys a3 clear a2_right cases a3 case _ a3_left a3_right => apply Exists.intro ([xs] ++ ys) simp tauto	α : Type R : RegExp α cs : List α right : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	no goals	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α right : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	apply Exists.intro []	α : Type R : RegExp α cs : List α left : cs = [] ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	α : Type R : RegExp α cs : List α left : cs = [] ⊢ (∀ r ∈ [], r ∈ RegExp.languageOf α R) ∧ [].join = cs	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α left : cs = [] ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	simp	α : Type R : RegExp α cs : List α left : cs = [] ⊢ (∀ r ∈ [], r ∈ RegExp.languageOf α R) ∧ [].join = cs	α : Type R : RegExp α cs : List α left : cs = [] ⊢ [] = cs	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α left : cs = [] ⊢ (∀ r ∈ [], r ∈ RegExp.languageOf α R) ∧ [].join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	simp only [left]	α : Type R : RegExp α cs : List α left : cs = [] ⊢ [] = cs	no goals	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α left : cs = [] ⊢ [] = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	apply Exists.elim right	α : Type R : RegExp α cs : List α right : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	α : Type R : RegExp α cs : List α right : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∀ (a : List α), (a ∈ RegExp.languageOf α R ∧ ∃ a_1, (∀ r ∈ a_1, r ∈ RegExp.languageOf α R) ∧ a ++ a_1.join = cs) → ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α right : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	intro xs a2	α : Type R : RegExp α cs : List α right : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∀ (a : List α), (a ∈ RegExp.languageOf α R ∧ ∃ a_1, (∀ r ∈ a_1, r ∈ RegExp.languageOf α R) ∧ a ++ a_1.join = cs) → ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	α : Type R : RegExp α cs : List α right : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs xs : List α a2 : xs ∈ RegExp.languageOf α R ∧ ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α right : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∀ (a : List α), (a ∈ RegExp.languageOf α R ∧ ∃ a_1, (∀ r ∈ a_1, r ∈ RegExp.languageOf α R) ∧ a ++ a_1.join = cs) → ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	clear right	α : Type R : RegExp α cs : List α right : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs xs : List α a2 : xs ∈ RegExp.languageOf α R ∧ ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	α : Type R : RegExp α cs xs : List α a2 : xs ∈ RegExp.languageOf α R ∧ ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α right : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs xs : List α a2 : xs ∈ RegExp.languageOf α R ∧ ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	cases a2	α : Type R : RegExp α cs xs : List α a2 : xs ∈ RegExp.languageOf α R ∧ ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	case intro α : Type R : RegExp α cs xs : List α left✝ : xs ∈ RegExp.languageOf α R right✝ : ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs xs : List α a2 : xs ∈ RegExp.languageOf α R ∧ ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	case _ a2_left a2_right => apply Exists.elim a2_right intro ys a3 clear a2_right cases a3 case _ a3_left a3_right => apply Exists.intro ([xs] ++ ys) simp tauto	α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R a2_right : ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	no goals	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R a2_right : ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	apply Exists.elim a2_right	α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R a2_right : ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R a2_right : ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∀ (a : List (List α)), (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs → ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R a2_right : ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	intro ys a3	α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R a2_right : ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∀ (a : List (List α)), (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs → ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R a2_right : ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ys : List (List α) a3 : (∀ r ∈ ys, r ∈ RegExp.languageOf α R) ∧ xs ++ ys.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R a2_right : ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∀ (a : List (List α)), (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs → ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	clear a2_right	α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R a2_right : ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ys : List (List α) a3 : (∀ r ∈ ys, r ∈ RegExp.languageOf α R) ∧ xs ++ ys.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3 : (∀ r ∈ ys, r ∈ RegExp.languageOf α R) ∧ xs ++ ys.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R a2_right : ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ys : List (List α) a3 : (∀ r ∈ ys, r ∈ RegExp.languageOf α R) ∧ xs ++ ys.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	cases a3	α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3 : (∀ r ∈ ys, r ∈ RegExp.languageOf α R) ∧ xs ++ ys.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	case intro α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) left✝ : ∀ r ∈ ys, r ∈ RegExp.languageOf α R right✝ : xs ++ ys.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3 : (∀ r ∈ ys, r ∈ RegExp.languageOf α R) ∧ xs ++ ys.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	case _ a3_left a3_right => apply Exists.intro ([xs] ++ ys) simp tauto	α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3_left : ∀ r ∈ ys, r ∈ RegExp.languageOf α R a3_right : xs ++ ys.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	no goals	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3_left : ∀ r ∈ ys, r ∈ RegExp.languageOf α R a3_right : xs ++ ys.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	apply Exists.intro ([xs] ++ ys)	α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3_left : ∀ r ∈ ys, r ∈ RegExp.languageOf α R a3_right : xs ++ ys.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs	α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3_left : ∀ r ∈ ys, r ∈ RegExp.languageOf α R a3_right : xs ++ ys.join = cs ⊢ (∀ r ∈ [xs] ++ ys, r ∈ RegExp.languageOf α R) ∧ ([xs] ++ ys).join = cs	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3_left : ∀ r ∈ ys, r ∈ RegExp.languageOf α R a3_right : xs ++ ys.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	simp	α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3_left : ∀ r ∈ ys, r ∈ RegExp.languageOf α R a3_right : xs ++ ys.join = cs ⊢ (∀ r ∈ [xs] ++ ys, r ∈ RegExp.languageOf α R) ∧ ([xs] ++ ys).join = cs	α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3_left : ∀ r ∈ ys, r ∈ RegExp.languageOf α R a3_right : xs ++ ys.join = cs ⊢ (xs ∈ RegExp.languageOf α R ∧ ∀ a ∈ ys, a ∈ RegExp.languageOf α R) ∧ xs ++ ys.join = cs	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3_left : ∀ r ∈ ys, r ∈ RegExp.languageOf α R a3_right : xs ++ ys.join = cs ⊢ (∀ r ∈ [xs] ++ ys, r ∈ RegExp.languageOf α R) ∧ ([xs] ++ ys).join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/Parsing/RegExp.lean	equiv_language_of_closure	[36, 1]	[83, 18]	tauto	α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3_left : ∀ r ∈ ys, r ∈ RegExp.languageOf α R a3_right : xs ++ ys.join = cs ⊢ (xs ∈ RegExp.languageOf α R ∧ ∀ a ∈ ys, a ∈ RegExp.languageOf α R) ∧ xs ++ ys.join = cs	no goals	Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3_left : ∀ r ∈ ys, r ∈ RegExp.languageOf α R a3_right : xs ++ ys.join = cs ⊢ (xs ∈ RegExp.languageOf α R ∧ ∀ a ∈ ys, a ∈ RegExp.languageOf α R) ∧ xs ++ ys.join = cs TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Margaris/Fol.lean	FOL.NV.T_17_1	[241, 1]	[253, 13]	apply IsDeduct.mp_ (forall_ v P)	P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ IsDeduct Δ (fastReplaceFree v t P)	case a P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ IsDeduct Δ ((forall_ v P).imp_ (fastReplaceFree v t P)) case a P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ IsDeduct Δ (forall_ v P)	Please generate a tactic in lean4 to solve the state. STATE: P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ IsDeduct Δ (fastReplaceFree v t P) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Margaris/Fol.lean	FOL.NV.T_17_1	[241, 1]	[253, 13]	apply IsDeduct.axiom_	case a P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ IsDeduct Δ ((forall_ v P).imp_ (fastReplaceFree v t P))	case a.a P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ IsAxiom ((forall_ v P).imp_ (fastReplaceFree v t P))	Please generate a tactic in lean4 to solve the state. STATE: case a P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ IsDeduct Δ ((forall_ v P).imp_ (fastReplaceFree v t P)) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Margaris/Fol.lean	FOL.NV.T_17_1	[241, 1]	[253, 13]	apply IsAxiom.pred_2_ v t P (fastReplaceFree v t P) h2	case a.a P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ IsAxiom ((forall_ v P).imp_ (fastReplaceFree v t P))	case a.a P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ fastReplaceFree v t P = fastReplaceFree v t P	Please generate a tactic in lean4 to solve the state. STATE: case a.a P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ IsAxiom ((forall_ v P).imp_ (fastReplaceFree v t P)) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Margaris/Fol.lean	FOL.NV.T_17_1	[241, 1]	[253, 13]	rfl	case a.a P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ fastReplaceFree v t P = fastReplaceFree v t P	no goals	Please generate a tactic in lean4 to solve the state. STATE: case a.a P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ fastReplaceFree v t P = fastReplaceFree v t P TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Margaris/Fol.lean	FOL.NV.T_17_1	[241, 1]	[253, 13]	exact h1	case a P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ IsDeduct Δ (forall_ v P)	no goals	Please generate a tactic in lean4 to solve the state. STATE: case a P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ IsDeduct Δ (forall_ v P) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Margaris/Fol.lean	FOL.NV.specId	[259, 1]	[271, 13]	apply IsDeduct.mp_ (forall_ v P)	v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ IsDeduct Δ P	case a v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ IsDeduct Δ ((forall_ v P).imp_ P) case a v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ IsDeduct Δ (forall_ v P)	Please generate a tactic in lean4 to solve the state. STATE: v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ IsDeduct Δ P TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Margaris/Fol.lean	FOL.NV.specId	[259, 1]	[271, 13]	apply IsDeduct.axiom_	case a v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ IsDeduct Δ ((forall_ v P).imp_ P)	case a.a v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ IsAxiom ((forall_ v P).imp_ P)	Please generate a tactic in lean4 to solve the state. STATE: case a v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ IsDeduct Δ ((forall_ v P).imp_ P) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Margaris/Fol.lean	FOL.NV.specId	[259, 1]	[271, 13]	apply IsAxiom.pred_2_ v v P	case a.a v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ IsAxiom ((forall_ v P).imp_ P)	case a.a.a v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ fastAdmits v v P case a.a.a v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ fastReplaceFree v v P = P	Please generate a tactic in lean4 to solve the state. STATE: case a.a v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ IsAxiom ((forall_ v P).imp_ P) TACTIC:
https://github.com/pthomas505/FOL.git	097a4abea51b641d144539b9a0f7516f3b9d818c	FOL/NV/Margaris/Fol.lean	FOL.NV.specId	[259, 1]	[271, 13]	exact fastAdmits_self P v	case a.a.a v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ fastAdmits v v P	no goals	Please generate a tactic in lean4 to solve the state. STATE: case a.a.a v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ fastAdmits v v P TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_updateIte

[551, 1]

[581, 20]

simp only [Function.updateITE]

α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ⊢ updateITE f y z x = f x

α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ⊢ (if x = y then z else f x) = f x

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ⊢ updateITE f y z x = f x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_updateIte

[551, 1]

[581, 20]

simp only [if_neg h1]

α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ⊢ (if x = y then z else f x) = f x

no goals

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ⊢ (if x = y then z else f x) = f x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_updateIte

[551, 1]

[581, 20]

simp only [Function.updateListITE]

α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β ⊢ updateListITE (updateITE f y z) (xs_hd :: xs_tl) (ys_hd :: ys_tl) x = updateListITE f (xs_hd :: xs_tl) (ys_hd :: ys_tl) x

α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β ⊢ updateITE (updateListITE (updateITE f y z) xs_tl ys_tl) xs_hd ys_hd x = updateITE (updateListITE f xs_tl ys_tl) xs_hd ys_hd x

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β ⊢ updateListITE (updateITE f y z) (xs_hd :: xs_tl) (ys_hd :: ys_tl) x = updateListITE f (xs_hd :: xs_tl) (ys_hd :: ys_tl) x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_updateIte

[551, 1]

[581, 20]

simp only [Function.updateITE]

α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β ⊢ updateITE (updateListITE (updateITE f y z) xs_tl ys_tl) xs_hd ys_hd x = updateITE (updateListITE f xs_tl ys_tl) xs_hd ys_hd x

α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β ⊢ (if x = xs_hd then ys_hd else updateListITE (updateITE f y z) xs_tl ys_tl x) = if x = xs_hd then ys_hd else updateListITE f xs_tl ys_tl x

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β ⊢ updateITE (updateListITE (updateITE f y z) xs_tl ys_tl) xs_hd ys_hd x = updateITE (updateListITE f xs_tl ys_tl) xs_hd ys_hd x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_updateIte

[551, 1]

[581, 20]

split_ifs

α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β ⊢ (if x = xs_hd then ys_hd else updateListITE (updateITE f y z) xs_tl ys_tl x) = if x = xs_hd then ys_hd else updateListITE f xs_tl ys_tl x

case pos α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β h✝ : x = xs_hd ⊢ ys_hd = ys_hd case neg α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β h✝ : ¬x = xs_hd ⊢ updateListITE (updateITE f y z) xs_tl ys_tl x = updateListITE f xs_tl ys_tl x

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β ⊢ (if x = xs_hd then ys_hd else updateListITE (updateITE f y z) xs_tl ys_tl x) = if x = xs_hd then ys_hd else updateListITE f xs_tl ys_tl x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_updateIte

[551, 1]

[581, 20]

case pos c1 => rfl

α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β c1 : x = xs_hd ⊢ ys_hd = ys_hd

no goals

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β c1 : x = xs_hd ⊢ ys_hd = ys_hd TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_updateIte

[551, 1]

[581, 20]

case neg c1 => apply xs_ih

α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β c1 : ¬x = xs_hd ⊢ updateListITE (updateITE f y z) xs_tl ys_tl x = updateListITE f xs_tl ys_tl x

no goals

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β c1 : ¬x = xs_hd ⊢ updateListITE (updateITE f y z) xs_tl ys_tl x = updateListITE f xs_tl ys_tl x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_updateIte

[551, 1]

[581, 20]

rfl

α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β c1 : x = xs_hd ⊢ ys_hd = ys_hd

no goals

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β c1 : x = xs_hd ⊢ ys_hd = ys_hd TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_updateIte

[551, 1]

[581, 20]

apply xs_ih

α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β c1 : ¬x = xs_hd ⊢ updateListITE (updateITE f y z) xs_tl ys_tl x = updateListITE f xs_tl ys_tl x

no goals

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f : α → β x y : α z : β h1 : ¬x = y xs_hd : α xs_tl : List α xs_ih : ∀ (ys : List β), updateListITE (updateITE f y z) xs_tl ys x = updateListITE f xs_tl ys x ys_hd : β ys_tl : List β c1 : ¬x = xs_hd ⊢ updateListITE (updateITE f y z) xs_tl ys_tl x = updateListITE f xs_tl ys_tl x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_fun_coincide_mem_eq_len

[584, 1]

[604, 13]

have s1 : List.map f ys = List.map g ys

α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map g ys) x

case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length ⊢ List.map f ys = List.map g ys α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map g ys) x

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map g ys) x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_fun_coincide_mem_eq_len

[584, 1]

[604, 13]

simp only [List.map_eq_map_iff]

case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length ⊢ List.map f ys = List.map g ys α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map g ys) x

case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length ⊢ ∀ x ∈ ys, f x = g x α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map g ys) x

Please generate a tactic in lean4 to solve the state. STATE: case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length ⊢ List.map f ys = List.map g ys α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map g ys) x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_fun_coincide_mem_eq_len

[584, 1]

[604, 13]

exact h1

case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length ⊢ ∀ x ∈ ys, f x = g x α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map g ys) x

α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map g ys) x

Please generate a tactic in lean4 to solve the state. STATE: case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length ⊢ ∀ x ∈ ys, f x = g x α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map g ys) x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_fun_coincide_mem_eq_len

[584, 1]

[604, 13]

simp only [s1]

α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map g ys) x

α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ updateListITE f xs (List.map g ys) x = updateListITE g xs (List.map g ys) x

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map g ys) x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_fun_coincide_mem_eq_len

[584, 1]

[604, 13]

apply Function.updateListITE_mem_eq_len

α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ updateListITE f xs (List.map g ys) x = updateListITE g xs (List.map g ys) x

case h1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ x ∈ xs case h2 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ xs.length = (List.map g ys).length

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ updateListITE f xs (List.map g ys) x = updateListITE g xs (List.map g ys) x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_fun_coincide_mem_eq_len

[584, 1]

[604, 13]

exact h2

case h1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ x ∈ xs

no goals

Please generate a tactic in lean4 to solve the state. STATE: case h1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ x ∈ xs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_fun_coincide_mem_eq_len

[584, 1]

[604, 13]

simp

case h2 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ xs.length = (List.map g ys).length

case h2 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ xs.length = ys.length

Please generate a tactic in lean4 to solve the state. STATE: case h2 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ xs.length = (List.map g ys).length TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_fun_coincide_mem_eq_len

[584, 1]

[604, 13]

exact h3

case h2 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ xs.length = ys.length

no goals

Please generate a tactic in lean4 to solve the state. STATE: case h2 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α x : α h1 : ∀ v ∈ ys, f v = g v h2 : x ∈ xs h3 : xs.length = ys.length s1 : List.map f ys = List.map g ys ⊢ xs.length = ys.length TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_mem_ext

[607, 1]

[627, 13]

have s1 : List.map h ys = List.map h' ys

α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs ⊢ updateListITE f xs (List.map h ys) x = updateListITE g xs (List.map h' ys) x

case s1 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs ⊢ List.map h ys = List.map h' ys α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ updateListITE f xs (List.map h ys) x = updateListITE g xs (List.map h' ys) x

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs ⊢ updateListITE f xs (List.map h ys) x = updateListITE g xs (List.map h' ys) x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_mem_ext

[607, 1]

[627, 13]

simp only [List.map_eq_map_iff]

case s1 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs ⊢ List.map h ys = List.map h' ys α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ updateListITE f xs (List.map h ys) x = updateListITE g xs (List.map h' ys) x

case s1 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs ⊢ ∀ x ∈ ys, h x = h' x α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ updateListITE f xs (List.map h ys) x = updateListITE g xs (List.map h' ys) x

Please generate a tactic in lean4 to solve the state. STATE: case s1 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs ⊢ List.map h ys = List.map h' ys α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ updateListITE f xs (List.map h ys) x = updateListITE g xs (List.map h' ys) x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_mem_ext

[607, 1]

[627, 13]

exact h1

case s1 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs ⊢ ∀ x ∈ ys, h x = h' x α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ updateListITE f xs (List.map h ys) x = updateListITE g xs (List.map h' ys) x

α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ updateListITE f xs (List.map h ys) x = updateListITE g xs (List.map h' ys) x

Please generate a tactic in lean4 to solve the state. STATE: case s1 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs ⊢ ∀ x ∈ ys, h x = h' x α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ updateListITE f xs (List.map h ys) x = updateListITE g xs (List.map h' ys) x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_mem_ext

[607, 1]

[627, 13]

simp only [s1]

α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ updateListITE f xs (List.map h ys) x = updateListITE g xs (List.map h' ys) x

α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ updateListITE f xs (List.map h' ys) x = updateListITE g xs (List.map h' ys) x

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ updateListITE f xs (List.map h ys) x = updateListITE g xs (List.map h' ys) x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_mem_ext

[607, 1]

[627, 13]

apply Function.updateListITE_mem_eq_len

α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ updateListITE f xs (List.map h' ys) x = updateListITE g xs (List.map h' ys) x

case h1 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ x ∈ xs case h2 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ xs.length = (List.map h' ys).length

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ updateListITE f xs (List.map h' ys) x = updateListITE g xs (List.map h' ys) x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_mem_ext

[607, 1]

[627, 13]

exact h3

case h1 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ x ∈ xs

no goals

Please generate a tactic in lean4 to solve the state. STATE: case h1 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ x ∈ xs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_mem_ext

[607, 1]

[627, 13]

simp

case h2 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ xs.length = (List.map h' ys).length

case h2 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ xs.length = ys.length

Please generate a tactic in lean4 to solve the state. STATE: case h2 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ xs.length = (List.map h' ys).length TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_mem_ext

[607, 1]

[627, 13]

exact h2

case h2 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ xs.length = ys.length

no goals

Please generate a tactic in lean4 to solve the state. STATE: case h2 α β : Type inst✝ : DecidableEq α xs ys : List α f g h h' : α → β x : α h1 : ∀ y ∈ ys, h y = h' y h2 : xs.length = ys.length h3 : x ∈ xs s1 : List.map h ys = List.map h' ys ⊢ xs.length = ys.length TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_mem

[630, 1]

[653, 12]

induction xs

α β : Type inst✝ : DecidableEq α f g : α → β xs : List α x : α h1 : x ∈ xs ⊢ updateListITE f xs (List.map g xs) x = g x

case nil α β : Type inst✝ : DecidableEq α f g : α → β x : α h1 : x ∈ [] ⊢ updateListITE f [] (List.map g []) x = g x case cons α β : Type inst✝ : DecidableEq α f g : α → β x head✝ : α tail✝ : List α tail_ih✝ : x ∈ tail✝ → updateListITE f tail✝ (List.map g tail✝) x = g x h1 : x ∈ head✝ :: tail✝ ⊢ updateListITE f (head✝ :: tail✝) (List.map g (head✝ :: tail✝)) x = g x

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β xs : List α x : α h1 : x ∈ xs ⊢ updateListITE f xs (List.map g xs) x = g x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_mem

[630, 1]

[653, 12]

case nil => simp at h1

α β : Type inst✝ : DecidableEq α f g : α → β x : α h1 : x ∈ [] ⊢ updateListITE f [] (List.map g []) x = g x

no goals

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x : α h1 : x ∈ [] ⊢ updateListITE f [] (List.map g []) x = g x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_mem

[630, 1]

[653, 12]

case cons hd tl ih => simp at h1 simp simp only [Function.updateListITE] simp only [Function.updateITE] split_ifs case _ c1 => subst c1 rfl case _ c1 => tauto

α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x ∈ hd :: tl ⊢ updateListITE f (hd :: tl) (List.map g (hd :: tl)) x = g x

no goals

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x ∈ hd :: tl ⊢ updateListITE f (hd :: tl) (List.map g (hd :: tl)) x = g x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_mem

[630, 1]

[653, 12]

simp at h1

α β : Type inst✝ : DecidableEq α f g : α → β x : α h1 : x ∈ [] ⊢ updateListITE f [] (List.map g []) x = g x

no goals

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x : α h1 : x ∈ [] ⊢ updateListITE f [] (List.map g []) x = g x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_mem

[630, 1]

[653, 12]

simp at h1

α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x ∈ hd :: tl ⊢ updateListITE f (hd :: tl) (List.map g (hd :: tl)) x = g x

α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl ⊢ updateListITE f (hd :: tl) (List.map g (hd :: tl)) x = g x

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x ∈ hd :: tl ⊢ updateListITE f (hd :: tl) (List.map g (hd :: tl)) x = g x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_mem

[630, 1]

[653, 12]

simp

α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl ⊢ updateListITE f (hd :: tl) (List.map g (hd :: tl)) x = g x

α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl ⊢ updateListITE f (hd :: tl) (g hd :: List.map g tl) x = g x

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl ⊢ updateListITE f (hd :: tl) (List.map g (hd :: tl)) x = g x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_mem

[630, 1]

[653, 12]

simp only [Function.updateListITE]

α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl ⊢ updateListITE f (hd :: tl) (g hd :: List.map g tl) x = g x

α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl ⊢ updateITE (updateListITE f tl (List.map g tl)) hd (g hd) x = g x

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl ⊢ updateListITE f (hd :: tl) (g hd :: List.map g tl) x = g x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_mem

[630, 1]

[653, 12]

simp only [Function.updateITE]

α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl ⊢ updateITE (updateListITE f tl (List.map g tl)) hd (g hd) x = g x

α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl ⊢ (if x = hd then g hd else updateListITE f tl (List.map g tl) x) = g x

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl ⊢ updateITE (updateListITE f tl (List.map g tl)) hd (g hd) x = g x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_mem

[630, 1]

[653, 12]

split_ifs

α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl ⊢ (if x = hd then g hd else updateListITE f tl (List.map g tl) x) = g x

case pos α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl h✝ : x = hd ⊢ g hd = g x case neg α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl h✝ : ¬x = hd ⊢ updateListITE f tl (List.map g tl) x = g x

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl ⊢ (if x = hd then g hd else updateListITE f tl (List.map g tl) x) = g x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_mem

[630, 1]

[653, 12]

case _ c1 => subst c1 rfl

α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl c1 : x = hd ⊢ g hd = g x

no goals

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl c1 : x = hd ⊢ g hd = g x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_mem

[630, 1]

[653, 12]

case _ c1 => tauto

α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl c1 : ¬x = hd ⊢ updateListITE f tl (List.map g tl) x = g x

no goals

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl c1 : ¬x = hd ⊢ updateListITE f tl (List.map g tl) x = g x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_mem

[630, 1]

[653, 12]

subst c1

α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl c1 : x = hd ⊢ g hd = g x

α β : Type inst✝ : DecidableEq α f g : α → β x : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = x ∨ x ∈ tl ⊢ g x = g x

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl c1 : x = hd ⊢ g hd = g x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_mem

[630, 1]

[653, 12]

rfl

α β : Type inst✝ : DecidableEq α f g : α → β x : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = x ∨ x ∈ tl ⊢ g x = g x

no goals

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = x ∨ x ∈ tl ⊢ g x = g x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_mem

[630, 1]

[653, 12]

tauto

α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl c1 : ¬x = hd ⊢ updateListITE f tl (List.map g tl) x = g x

no goals

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β x hd : α tl : List α ih : x ∈ tl → updateListITE f tl (List.map g tl) x = g x h1 : x = hd ∨ x ∈ tl c1 : ¬x = hd ⊢ updateListITE f tl (List.map g tl) x = g x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_updateIte

[656, 1]

[680, 93]

have s1 : ∀ (y : α), y ∈ ys → f y =Function.updateITE f v a y

α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x

case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs ⊢ ∀ y ∈ ys, f y = updateITE f v a y α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs s1 : ∀ y ∈ ys, f y = updateITE f v a y ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_updateIte

[656, 1]

[680, 93]

intro y a1

case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs ⊢ ∀ y ∈ ys, f y = updateITE f v a y α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs s1 : ∀ y ∈ ys, f y = updateITE f v a y ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x

case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys ⊢ f y = updateITE f v a y α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs s1 : ∀ y ∈ ys, f y = updateITE f v a y ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x

Please generate a tactic in lean4 to solve the state. STATE: case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs ⊢ ∀ y ∈ ys, f y = updateITE f v a y α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs s1 : ∀ y ∈ ys, f y = updateITE f v a y ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_updateIte

[656, 1]

[680, 93]

simp only [Function.updateITE]

case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys ⊢ f y = updateITE f v a y α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs s1 : ∀ y ∈ ys, f y = updateITE f v a y ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x

case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys ⊢ f y = if y = v then a else f y α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs s1 : ∀ y ∈ ys, f y = updateITE f v a y ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x

Please generate a tactic in lean4 to solve the state. STATE: case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys ⊢ f y = updateITE f v a y α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs s1 : ∀ y ∈ ys, f y = updateITE f v a y ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_updateIte

[656, 1]

[680, 93]

split_ifs

case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys ⊢ f y = if y = v then a else f y α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs s1 : ∀ y ∈ ys, f y = updateITE f v a y ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x

case pos α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys h✝ : y = v ⊢ f y = a case neg α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys h✝ : ¬y = v ⊢ f y = f y α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs s1 : ∀ y ∈ ys, f y = updateITE f v a y ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x

Please generate a tactic in lean4 to solve the state. STATE: case s1 α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys ⊢ f y = if y = v then a else f y α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs s1 : ∀ y ∈ ys, f y = updateITE f v a y ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_updateIte

[656, 1]

[680, 93]

case _ c1 => specialize h1 y a1 contradiction

α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys c1 : y = v ⊢ f y = a

no goals

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys c1 : y = v ⊢ f y = a TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_updateIte

[656, 1]

[680, 93]

case _ c2 => rfl

α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys c2 : ¬y = v ⊢ f y = f y

no goals

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys c2 : ¬y = v ⊢ f y = f y TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_updateIte

[656, 1]

[680, 93]

exact Function.updateListITE_map_mem_ext xs ys f g f (Function.updateITE f v a) x s1 h2 h3

α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs s1 : ∀ y ∈ ys, f y = updateITE f v a y ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x

no goals

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs s1 : ∀ y ∈ ys, f y = updateITE f v a y ⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map (updateITE f v a) ys) x TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_updateIte

[656, 1]

[680, 93]

specialize h1 y a1

α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys c1 : y = v ⊢ f y = a

α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys c1 : y = v h1 : ¬y = v ⊢ f y = a

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys c1 : y = v ⊢ f y = a TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_updateIte

[656, 1]

[680, 93]

contradiction

α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys c1 : y = v h1 : ¬y = v ⊢ f y = a

no goals

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys c1 : y = v h1 : ¬y = v ⊢ f y = a TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/FunctionUpdateITE.lean

Function.updateListITE_map_updateIte

[656, 1]

[680, 93]

rfl

α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys c2 : ¬y = v ⊢ f y = f y

no goals

Please generate a tactic in lean4 to solve the state. STATE: α β : Type inst✝ : DecidableEq α f g : α → β xs ys : List α v : α a : β x : α h1 : ∀ y ∈ ys, ¬y = v h2 : xs.length = ys.length h3 : x ∈ xs y : α a1 : y ∈ ys c2 : ¬y = v ⊢ f y = f y TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

ext cs

α : Type R : RegExp α ⊢ RegExp.languageOf α R.closure = RegExp.languageOf α (RegExp.epsilon.union (R.concat R.closure))

case h α : Type R : RegExp α cs : List α ⊢ cs ∈ RegExp.languageOf α R.closure ↔ cs ∈ RegExp.languageOf α (RegExp.epsilon.union (R.concat R.closure))

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α ⊢ RegExp.languageOf α R.closure = RegExp.languageOf α (RegExp.epsilon.union (R.concat R.closure)) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

simp only [RegExp.languageOf]

case h α : Type R : RegExp α cs : List α ⊢ cs ∈ RegExp.languageOf α R.closure ↔ cs ∈ RegExp.languageOf α (RegExp.epsilon.union (R.concat R.closure))

case h α : Type R : RegExp α cs : List α ⊢ cs ∈ {l | ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = l} ↔ cs ∈ {[]} ∪ {x | ∃ r ∈ RegExp.languageOf α R, ∃ s ∈ {l | ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = l}, r ++ s = x}

Please generate a tactic in lean4 to solve the state. STATE: case h α : Type R : RegExp α cs : List α ⊢ cs ∈ RegExp.languageOf α R.closure ↔ cs ∈ RegExp.languageOf α (RegExp.epsilon.union (R.concat R.closure)) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

simp

case h α : Type R : RegExp α cs : List α ⊢ cs ∈ {l | ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = l} ↔ cs ∈ {[]} ∪ {x | ∃ r ∈ RegExp.languageOf α R, ∃ s ∈ {l | ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = l}, r ++ s = x}

case h α : Type R : RegExp α cs : List α ⊢ (∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs) ↔ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

Please generate a tactic in lean4 to solve the state. STATE: case h α : Type R : RegExp α cs : List α ⊢ cs ∈ {l | ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = l} ↔ cs ∈ {[]} ∪ {x | ∃ r ∈ RegExp.languageOf α R, ∃ s ∈ {l | ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = l}, r ++ s = x} TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

constructor

case h α : Type R : RegExp α cs : List α ⊢ (∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs) ↔ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

case h.mp α : Type R : RegExp α cs : List α ⊢ (∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs) → cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs case h.mpr α : Type R : RegExp α cs : List α ⊢ (cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs) → ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

Please generate a tactic in lean4 to solve the state. STATE: case h α : Type R : RegExp α cs : List α ⊢ (∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs) ↔ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

intro a1

case h.mp α : Type R : RegExp α cs : List α ⊢ (∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs) → cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

Please generate a tactic in lean4 to solve the state. STATE: case h.mp α : Type R : RegExp α cs : List α ⊢ (∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs) → cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

apply Exists.elim a1

case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs ⊢ ∀ (a : List (List α)), (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ a.join = cs → cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

Please generate a tactic in lean4 to solve the state. STATE: case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

intro xs a2

case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs ⊢ ∀ (a : List (List α)), (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ a.join = cs → cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs xs : List (List α) a2 : (∀ r ∈ xs, r ∈ RegExp.languageOf α R) ∧ xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

Please generate a tactic in lean4 to solve the state. STATE: case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs ⊢ ∀ (a : List (List α)), (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ a.join = cs → cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

clear a1

case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs xs : List (List α) a2 : (∀ r ∈ xs, r ∈ RegExp.languageOf α R) ∧ xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

case h.mp α : Type R : RegExp α cs : List α xs : List (List α) a2 : (∀ r ∈ xs, r ∈ RegExp.languageOf α R) ∧ xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

Please generate a tactic in lean4 to solve the state. STATE: case h.mp α : Type R : RegExp α cs : List α a1 : ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs xs : List (List α) a2 : (∀ r ∈ xs, r ∈ RegExp.languageOf α R) ∧ xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

cases a2

case h.mp α : Type R : RegExp α cs : List α xs : List (List α) a2 : (∀ r ∈ xs, r ∈ RegExp.languageOf α R) ∧ xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

case h.mp.intro α : Type R : RegExp α cs : List α xs : List (List α) left✝ : ∀ r ∈ xs, r ∈ RegExp.languageOf α R right✝ : xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

Please generate a tactic in lean4 to solve the state. STATE: case h.mp α : Type R : RegExp α cs : List α xs : List (List α) a2 : (∀ r ∈ xs, r ∈ RegExp.languageOf α R) ∧ xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

case _ a2_left a2_right => simp only [← a2_right] cases xs case nil => left simp case cons hd tl => right simp at a2_left cases a2_left case _ a2_left_left a2_left_right => apply Exists.intro hd tauto

α : Type R : RegExp α cs : List α xs : List (List α) a2_left : ∀ r ∈ xs, r ∈ RegExp.languageOf α R a2_right : xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

no goals

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α xs : List (List α) a2_left : ∀ r ∈ xs, r ∈ RegExp.languageOf α R a2_right : xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

simp only [← a2_right]

α : Type R : RegExp α cs : List α xs : List (List α) a2_left : ∀ r ∈ xs, r ∈ RegExp.languageOf α R a2_right : xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs

α : Type R : RegExp α cs : List α xs : List (List α) a2_left : ∀ r ∈ xs, r ∈ RegExp.languageOf α R a2_right : xs.join = cs ⊢ xs.join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = xs.join

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α xs : List (List α) a2_left : ∀ r ∈ xs, r ∈ RegExp.languageOf α R a2_right : xs.join = cs ⊢ cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

cases xs

α : Type R : RegExp α cs : List α xs : List (List α) a2_left : ∀ r ∈ xs, r ∈ RegExp.languageOf α R a2_right : xs.join = cs ⊢ xs.join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = xs.join

case nil α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = [].join case cons α : Type R : RegExp α cs head✝ : List α tail✝ : List (List α) a2_left : ∀ r ∈ head✝ :: tail✝, r ∈ RegExp.languageOf α R a2_right : (head✝ :: tail✝).join = cs ⊢ (head✝ :: tail✝).join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (head✝ :: tail✝).join

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α xs : List (List α) a2_left : ∀ r ∈ xs, r ∈ RegExp.languageOf α R a2_right : xs.join = cs ⊢ xs.join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = xs.join TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

case nil => left simp

α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = [].join

no goals

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = [].join TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

case cons hd tl => right simp at a2_left cases a2_left case _ a2_left_left a2_left_right => apply Exists.intro hd tauto

α : Type R : RegExp α cs hd : List α tl : List (List α) a2_left : ∀ r ∈ hd :: tl, r ∈ RegExp.languageOf α R a2_right : (hd :: tl).join = cs ⊢ (hd :: tl).join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join

no goals

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs hd : List α tl : List (List α) a2_left : ∀ r ∈ hd :: tl, r ∈ RegExp.languageOf α R a2_right : (hd :: tl).join = cs ⊢ (hd :: tl).join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

left

α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = [].join

case h α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = []

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = [].join TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

simp

case h α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = []

no goals

Please generate a tactic in lean4 to solve the state. STATE: case h α : Type R : RegExp α cs : List α a2_left : ∀ r ∈ [], r ∈ RegExp.languageOf α R a2_right : [].join = cs ⊢ [].join = [] TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

right

α : Type R : RegExp α cs hd : List α tl : List (List α) a2_left : ∀ r ∈ hd :: tl, r ∈ RegExp.languageOf α R a2_right : (hd :: tl).join = cs ⊢ (hd :: tl).join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join

case h α : Type R : RegExp α cs hd : List α tl : List (List α) a2_left : ∀ r ∈ hd :: tl, r ∈ RegExp.languageOf α R a2_right : (hd :: tl).join = cs ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs hd : List α tl : List (List α) a2_left : ∀ r ∈ hd :: tl, r ∈ RegExp.languageOf α R a2_right : (hd :: tl).join = cs ⊢ (hd :: tl).join = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

simp at a2_left

case h α : Type R : RegExp α cs hd : List α tl : List (List α) a2_left : ∀ r ∈ hd :: tl, r ∈ RegExp.languageOf α R a2_right : (hd :: tl).join = cs ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join

case h α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left : hd ∈ RegExp.languageOf α R ∧ ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join

Please generate a tactic in lean4 to solve the state. STATE: case h α : Type R : RegExp α cs hd : List α tl : List (List α) a2_left : ∀ r ∈ hd :: tl, r ∈ RegExp.languageOf α R a2_right : (hd :: tl).join = cs ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

cases a2_left

case h α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left : hd ∈ RegExp.languageOf α R ∧ ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join

case h.intro α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs left✝ : hd ∈ RegExp.languageOf α R right✝ : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join

Please generate a tactic in lean4 to solve the state. STATE: case h α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left : hd ∈ RegExp.languageOf α R ∧ ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

case _ a2_left_left a2_left_right => apply Exists.intro hd tauto

α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left_left : hd ∈ RegExp.languageOf α R a2_left_right : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join

no goals

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left_left : hd ∈ RegExp.languageOf α R a2_left_right : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

apply Exists.intro hd

α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left_left : hd ∈ RegExp.languageOf α R a2_left_right : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join

α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left_left : hd ∈ RegExp.languageOf α R a2_left_right : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ hd ∈ RegExp.languageOf α R ∧ ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ hd ++ a.join = (hd :: tl).join

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left_left : hd ∈ RegExp.languageOf α R a2_left_right : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = (hd :: tl).join TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

tauto

α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left_left : hd ∈ RegExp.languageOf α R a2_left_right : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ hd ∈ RegExp.languageOf α R ∧ ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ hd ++ a.join = (hd :: tl).join

no goals

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs hd : List α tl : List (List α) a2_right : (hd :: tl).join = cs a2_left_left : hd ∈ RegExp.languageOf α R a2_left_right : ∀ a ∈ tl, a ∈ RegExp.languageOf α R ⊢ hd ∈ RegExp.languageOf α R ∧ ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ hd ++ a.join = (hd :: tl).join TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

intro a1

case h.mpr α : Type R : RegExp α cs : List α ⊢ (cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs) → ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

case h.mpr α : Type R : RegExp α cs : List α a1 : cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

Please generate a tactic in lean4 to solve the state. STATE: case h.mpr α : Type R : RegExp α cs : List α ⊢ (cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs) → ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

cases a1

case h.mpr α : Type R : RegExp α cs : List α a1 : cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

case h.mpr.inl α : Type R : RegExp α cs : List α h✝ : cs = [] ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs case h.mpr.inr α : Type R : RegExp α cs : List α h✝ : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

Please generate a tactic in lean4 to solve the state. STATE: case h.mpr α : Type R : RegExp α cs : List α a1 : cs = [] ∨ ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

case _ left => apply Exists.intro [] simp simp only [left]

α : Type R : RegExp α cs : List α left : cs = [] ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

no goals

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α left : cs = [] ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

case _ right => apply Exists.elim right intro xs a2 clear right cases a2 case _ a2_left a2_right => apply Exists.elim a2_right intro ys a3 clear a2_right cases a3 case _ a3_left a3_right => apply Exists.intro ([xs] ++ ys) simp tauto

α : Type R : RegExp α cs : List α right : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

no goals

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α right : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

apply Exists.intro []

α : Type R : RegExp α cs : List α left : cs = [] ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

α : Type R : RegExp α cs : List α left : cs = [] ⊢ (∀ r ∈ [], r ∈ RegExp.languageOf α R) ∧ [].join = cs

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α left : cs = [] ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

simp

α : Type R : RegExp α cs : List α left : cs = [] ⊢ (∀ r ∈ [], r ∈ RegExp.languageOf α R) ∧ [].join = cs

α : Type R : RegExp α cs : List α left : cs = [] ⊢ [] = cs

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α left : cs = [] ⊢ (∀ r ∈ [], r ∈ RegExp.languageOf α R) ∧ [].join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

simp only [left]

α : Type R : RegExp α cs : List α left : cs = [] ⊢ [] = cs

no goals

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α left : cs = [] ⊢ [] = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

apply Exists.elim right

α : Type R : RegExp α cs : List α right : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

α : Type R : RegExp α cs : List α right : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∀ (a : List α), (a ∈ RegExp.languageOf α R ∧ ∃ a_1, (∀ r ∈ a_1, r ∈ RegExp.languageOf α R) ∧ a ++ a_1.join = cs) → ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α right : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

intro xs a2

α : Type R : RegExp α cs : List α right : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∀ (a : List α), (a ∈ RegExp.languageOf α R ∧ ∃ a_1, (∀ r ∈ a_1, r ∈ RegExp.languageOf α R) ∧ a ++ a_1.join = cs) → ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

α : Type R : RegExp α cs : List α right : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs xs : List α a2 : xs ∈ RegExp.languageOf α R ∧ ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α right : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs ⊢ ∀ (a : List α), (a ∈ RegExp.languageOf α R ∧ ∃ a_1, (∀ r ∈ a_1, r ∈ RegExp.languageOf α R) ∧ a ++ a_1.join = cs) → ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

clear right

α : Type R : RegExp α cs : List α right : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs xs : List α a2 : xs ∈ RegExp.languageOf α R ∧ ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

α : Type R : RegExp α cs xs : List α a2 : xs ∈ RegExp.languageOf α R ∧ ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs : List α right : ∃ r ∈ RegExp.languageOf α R, ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ r ++ a.join = cs xs : List α a2 : xs ∈ RegExp.languageOf α R ∧ ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

cases a2

α : Type R : RegExp α cs xs : List α a2 : xs ∈ RegExp.languageOf α R ∧ ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

case intro α : Type R : RegExp α cs xs : List α left✝ : xs ∈ RegExp.languageOf α R right✝ : ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs xs : List α a2 : xs ∈ RegExp.languageOf α R ∧ ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

case _ a2_left a2_right => apply Exists.elim a2_right intro ys a3 clear a2_right cases a3 case _ a3_left a3_right => apply Exists.intro ([xs] ++ ys) simp tauto

α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R a2_right : ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

no goals

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R a2_right : ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

apply Exists.elim a2_right

α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R a2_right : ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R a2_right : ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∀ (a : List (List α)), (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs → ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R a2_right : ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

intro ys a3

α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R a2_right : ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∀ (a : List (List α)), (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs → ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R a2_right : ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ys : List (List α) a3 : (∀ r ∈ ys, r ∈ RegExp.languageOf α R) ∧ xs ++ ys.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R a2_right : ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ⊢ ∀ (a : List (List α)), (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs → ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

clear a2_right

α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R a2_right : ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ys : List (List α) a3 : (∀ r ∈ ys, r ∈ RegExp.languageOf α R) ∧ xs ++ ys.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3 : (∀ r ∈ ys, r ∈ RegExp.languageOf α R) ∧ xs ++ ys.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R a2_right : ∃ a, (∀ r ∈ a, r ∈ RegExp.languageOf α R) ∧ xs ++ a.join = cs ys : List (List α) a3 : (∀ r ∈ ys, r ∈ RegExp.languageOf α R) ∧ xs ++ ys.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

cases a3

α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3 : (∀ r ∈ ys, r ∈ RegExp.languageOf α R) ∧ xs ++ ys.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

case intro α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) left✝ : ∀ r ∈ ys, r ∈ RegExp.languageOf α R right✝ : xs ++ ys.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3 : (∀ r ∈ ys, r ∈ RegExp.languageOf α R) ∧ xs ++ ys.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

case _ a3_left a3_right => apply Exists.intro ([xs] ++ ys) simp tauto

α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3_left : ∀ r ∈ ys, r ∈ RegExp.languageOf α R a3_right : xs ++ ys.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

no goals

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3_left : ∀ r ∈ ys, r ∈ RegExp.languageOf α R a3_right : xs ++ ys.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

apply Exists.intro ([xs] ++ ys)

α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3_left : ∀ r ∈ ys, r ∈ RegExp.languageOf α R a3_right : xs ++ ys.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs

α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3_left : ∀ r ∈ ys, r ∈ RegExp.languageOf α R a3_right : xs ++ ys.join = cs ⊢ (∀ r ∈ [xs] ++ ys, r ∈ RegExp.languageOf α R) ∧ ([xs] ++ ys).join = cs

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3_left : ∀ r ∈ ys, r ∈ RegExp.languageOf α R a3_right : xs ++ ys.join = cs ⊢ ∃ rs, (∀ r ∈ rs, r ∈ RegExp.languageOf α R) ∧ rs.join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

simp

α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3_left : ∀ r ∈ ys, r ∈ RegExp.languageOf α R a3_right : xs ++ ys.join = cs ⊢ (∀ r ∈ [xs] ++ ys, r ∈ RegExp.languageOf α R) ∧ ([xs] ++ ys).join = cs

α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3_left : ∀ r ∈ ys, r ∈ RegExp.languageOf α R a3_right : xs ++ ys.join = cs ⊢ (xs ∈ RegExp.languageOf α R ∧ ∀ a ∈ ys, a ∈ RegExp.languageOf α R) ∧ xs ++ ys.join = cs

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3_left : ∀ r ∈ ys, r ∈ RegExp.languageOf α R a3_right : xs ++ ys.join = cs ⊢ (∀ r ∈ [xs] ++ ys, r ∈ RegExp.languageOf α R) ∧ ([xs] ++ ys).join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/Parsing/RegExp.lean

equiv_language_of_closure

[36, 1]

[83, 18]

tauto

α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3_left : ∀ r ∈ ys, r ∈ RegExp.languageOf α R a3_right : xs ++ ys.join = cs ⊢ (xs ∈ RegExp.languageOf α R ∧ ∀ a ∈ ys, a ∈ RegExp.languageOf α R) ∧ xs ++ ys.join = cs

no goals

Please generate a tactic in lean4 to solve the state. STATE: α : Type R : RegExp α cs xs : List α a2_left : xs ∈ RegExp.languageOf α R ys : List (List α) a3_left : ∀ r ∈ ys, r ∈ RegExp.languageOf α R a3_right : xs ++ ys.join = cs ⊢ (xs ∈ RegExp.languageOf α R ∧ ∀ a ∈ ys, a ∈ RegExp.languageOf α R) ∧ xs ++ ys.join = cs TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Margaris/Fol.lean

FOL.NV.T_17_1

[241, 1]

[253, 13]

apply IsDeduct.mp_ (forall_ v P)

P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ IsDeduct Δ (fastReplaceFree v t P)

case a P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ IsDeduct Δ ((forall_ v P).imp_ (fastReplaceFree v t P)) case a P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ IsDeduct Δ (forall_ v P)

Please generate a tactic in lean4 to solve the state. STATE: P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ IsDeduct Δ (fastReplaceFree v t P) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Margaris/Fol.lean

FOL.NV.T_17_1

[241, 1]

[253, 13]

apply IsDeduct.axiom_

case a P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ IsDeduct Δ ((forall_ v P).imp_ (fastReplaceFree v t P))

case a.a P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ IsAxiom ((forall_ v P).imp_ (fastReplaceFree v t P))

Please generate a tactic in lean4 to solve the state. STATE: case a P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ IsDeduct Δ ((forall_ v P).imp_ (fastReplaceFree v t P)) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Margaris/Fol.lean

FOL.NV.T_17_1

[241, 1]

[253, 13]

apply IsAxiom.pred_2_ v t P (fastReplaceFree v t P) h2

case a.a P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ IsAxiom ((forall_ v P).imp_ (fastReplaceFree v t P))

case a.a P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ fastReplaceFree v t P = fastReplaceFree v t P

Please generate a tactic in lean4 to solve the state. STATE: case a.a P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ IsAxiom ((forall_ v P).imp_ (fastReplaceFree v t P)) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Margaris/Fol.lean

FOL.NV.T_17_1

[241, 1]

[253, 13]

rfl

case a.a P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ fastReplaceFree v t P = fastReplaceFree v t P

no goals

Please generate a tactic in lean4 to solve the state. STATE: case a.a P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ fastReplaceFree v t P = fastReplaceFree v t P TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Margaris/Fol.lean

FOL.NV.T_17_1

[241, 1]

[253, 13]

exact h1

case a P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ IsDeduct Δ (forall_ v P)

no goals

Please generate a tactic in lean4 to solve the state. STATE: case a P : Formula v t : VarName Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) h2 : fastAdmits v t P ⊢ IsDeduct Δ (forall_ v P) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Margaris/Fol.lean

FOL.NV.specId

[259, 1]

[271, 13]

apply IsDeduct.mp_ (forall_ v P)

v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ IsDeduct Δ P

case a v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ IsDeduct Δ ((forall_ v P).imp_ P) case a v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ IsDeduct Δ (forall_ v P)

Please generate a tactic in lean4 to solve the state. STATE: v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ IsDeduct Δ P TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Margaris/Fol.lean

FOL.NV.specId

[259, 1]

[271, 13]

apply IsDeduct.axiom_

case a v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ IsDeduct Δ ((forall_ v P).imp_ P)

case a.a v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ IsAxiom ((forall_ v P).imp_ P)

Please generate a tactic in lean4 to solve the state. STATE: case a v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ IsDeduct Δ ((forall_ v P).imp_ P) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Margaris/Fol.lean

FOL.NV.specId

[259, 1]

[271, 13]

apply IsAxiom.pred_2_ v v P

case a.a v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ IsAxiom ((forall_ v P).imp_ P)

case a.a.a v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ fastAdmits v v P case a.a.a v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ fastReplaceFree v v P = P

Please generate a tactic in lean4 to solve the state. STATE: case a.a v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ IsAxiom ((forall_ v P).imp_ P) TACTIC:

https://github.com/pthomas505/FOL.git

097a4abea51b641d144539b9a0f7516f3b9d818c

FOL/NV/Margaris/Fol.lean

FOL.NV.specId

[259, 1]

[271, 13]

exact fastAdmits_self P v

case a.a.a v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ fastAdmits v v P

no goals

Please generate a tactic in lean4 to solve the state. STATE: case a.a.a v : VarName P : Formula Δ : Set Formula h1 : IsDeduct Δ (forall_ v P) ⊢ fastAdmits v v P TACTIC: