Datasets:
pkuAI4M
/
lean_github

Dataset card Data Studio Files
xet
Community
1
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/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : EpsilonArrow Οƒ_0 a2_left : x ∈ M_0.epsilon_arrow_list a2_right_left : x.start_state = p_0 a2_right_right : List.map (Sum.inr ∘ Sum.inl) x.stop_state_list = xs ⊒ Sum.inl q_0 βˆ‰ List.map (Sum.inr ∘ Sum.inl) x.stop_state_list
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : EpsilonArrow Οƒ_0 a2_left : x ∈ M_0.epsilon_arrow_list a2_right_left : x.start_state = p_0 a2_right_right : List.map (Sum.inr ∘ Sum.inl) x.stop_state_list = xs ⊒ Sum.inl q_0 βˆ‰ List.map (Sum.inr ∘ Sum.inl) x.stop_state_list TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
cases right
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) right : βˆƒ a ∈ M_0.accepting_state_list, a = p_0 ∧ List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = xs ⊒ Sum.inl q_0 βˆ‰ xs
case intro Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) w✝ : Οƒ_0 h✝ : w✝ ∈ M_0.accepting_state_list ∧ w✝ = p_0 ∧ List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = xs ⊒ Sum.inl q_0 βˆ‰ xs
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) right : βˆƒ a ∈ M_0.accepting_state_list, a = p_0 ∧ List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = xs ⊒ Sum.inl q_0 βˆ‰ xs TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
case _ x a2 => cases a2 case _ a2_left a2_right => cases a2_right case _ a2_right_left a2_right_right => simp only [← a2_right_right] simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : Οƒ_0 a2 : x ∈ M_0.accepting_state_list ∧ x = p_0 ∧ List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = xs ⊒ Sum.inl q_0 βˆ‰ xs
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : Οƒ_0 a2 : x ∈ M_0.accepting_state_list ∧ x = p_0 ∧ List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = xs ⊒ Sum.inl q_0 βˆ‰ xs TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
cases a2
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : Οƒ_0 a2 : x ∈ M_0.accepting_state_list ∧ x = p_0 ∧ List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = xs ⊒ Sum.inl q_0 βˆ‰ xs
case intro Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : Οƒ_0 left✝ : x ∈ M_0.accepting_state_list right✝ : x = p_0 ∧ List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = xs ⊒ Sum.inl q_0 βˆ‰ xs
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : Οƒ_0 a2 : x ∈ M_0.accepting_state_list ∧ x = p_0 ∧ List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = xs ⊒ Sum.inl q_0 βˆ‰ xs TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
case _ a2_left a2_right => cases a2_right case _ a2_right_left a2_right_right => simp only [← a2_right_right] simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : Οƒ_0 a2_left : x ∈ M_0.accepting_state_list a2_right : x = p_0 ∧ List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = xs ⊒ Sum.inl q_0 βˆ‰ xs
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : Οƒ_0 a2_left : x ∈ M_0.accepting_state_list a2_right : x = p_0 ∧ List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = xs ⊒ Sum.inl q_0 βˆ‰ xs TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
cases a2_right
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : Οƒ_0 a2_left : x ∈ M_0.accepting_state_list a2_right : x = p_0 ∧ List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = xs ⊒ Sum.inl q_0 βˆ‰ xs
case intro Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : Οƒ_0 a2_left : x ∈ M_0.accepting_state_list left✝ : x = p_0 right✝ : List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = xs ⊒ Sum.inl q_0 βˆ‰ xs
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : Οƒ_0 a2_left : x ∈ M_0.accepting_state_list a2_right : x = p_0 ∧ List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = xs ⊒ Sum.inl q_0 βˆ‰ xs TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
case _ a2_right_left a2_right_right => simp only [← a2_right_right] simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : Οƒ_0 a2_left : x ∈ M_0.accepting_state_list a2_right_left : x = p_0 a2_right_right : List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = xs ⊒ Sum.inl q_0 βˆ‰ xs
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : Οƒ_0 a2_left : x ∈ M_0.accepting_state_list a2_right_left : x = p_0 a2_right_right : List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = xs ⊒ Sum.inl q_0 βˆ‰ xs TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
simp only [← a2_right_right]
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : Οƒ_0 a2_left : x ∈ M_0.accepting_state_list a2_right_left : x = p_0 a2_right_right : List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = xs ⊒ Sum.inl q_0 βˆ‰ xs
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : Οƒ_0 a2_left : x ∈ M_0.accepting_state_list a2_right_left : x = p_0 a2_right_right : List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = xs ⊒ Sum.inl q_0 βˆ‰ List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : Οƒ_0 a2_left : x ∈ M_0.accepting_state_list a2_right_left : x = p_0 a2_right_right : List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = xs ⊒ Sum.inl q_0 βˆ‰ xs TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : Οƒ_0 a2_left : x ∈ M_0.accepting_state_list a2_right_left : x = p_0 a2_right_right : List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = xs ⊒ Sum.inl q_0 βˆ‰ List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : Οƒ_0 a2_left : x ∈ M_0.accepting_state_list a2_right_left : x = p_0 a2_right_right : List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = xs ⊒ Sum.inl q_0 βˆ‰ List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
cases q_0
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : Οƒ_0 βŠ• Οƒ_1 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inl p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr q_0 ∈ stop_state_list) = match (Sum.inr (Sum.inl p_0), Sum.inr q_0) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False
case inl Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 val✝ : Οƒ_0 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inl p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr (Sum.inl val✝) ∈ stop_state_list) = match (Sum.inr (Sum.inl p_0), Sum.inr (Sum.inl val✝)) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False case inr Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 val✝ : Οƒ_1 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inl p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr (Sum.inr val✝) ∈ stop_state_list) = match (Sum.inr (Sum.inl p_0), Sum.inr (Sum.inr val✝)) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : Οƒ_0 βŠ• Οƒ_1 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inl p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr q_0 ∈ stop_state_list) = match (Sum.inr (Sum.inl p_0), Sum.inr q_0) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
case _ q_0 => simp sorry
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 q_0 : Οƒ_0 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inl p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr (Sum.inl q_0) ∈ stop_state_list) = match (Sum.inr (Sum.inl p_0), Sum.inr (Sum.inl q_0)) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 q_0 : Οƒ_0 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inl p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr (Sum.inl q_0) ∈ stop_state_list) = match (Sum.inr (Sum.inl p_0), Sum.inr (Sum.inl q_0)) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
case _ q_0 => simp sorry
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : Οƒ_1 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inl p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr (Sum.inr q_0) ∈ stop_state_list) = match (Sum.inr (Sum.inl p_0), Sum.inr (Sum.inr q_0)) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : Οƒ_1 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inl p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr (Sum.inr q_0) ∈ stop_state_list) = match (Sum.inr (Sum.inl p_0), Sum.inr (Sum.inr q_0)) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 q_0 : Οƒ_0 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inl p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr (Sum.inl q_0) ∈ stop_state_list) = match (Sum.inr (Sum.inl p_0), Sum.inr (Sum.inl q_0)) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 q_0 : Οƒ_0 ⊒ (βˆƒ stop_state_list, ((βˆƒ a ∈ M_0.epsilon_arrow_list, a.start_state = p_0 ∧ List.map (Sum.inr ∘ Sum.inl) a.stop_state_list = stop_state_list) ∨ βˆƒ a ∈ M_0.accepting_state_list, a = p_0 ∧ List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = stop_state_list) ∧ Sum.inr (Sum.inl q_0) ∈ stop_state_list) ↔ βˆƒ stop_state_list, { start_state := p_0, stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q_0 ∈ stop_state_list
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 q_0 : Οƒ_0 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inl p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr (Sum.inl q_0) ∈ stop_state_list) = match (Sum.inr (Sum.inl p_0), Sum.inr (Sum.inl q_0)) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
sorry
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 q_0 : Οƒ_0 ⊒ (βˆƒ stop_state_list, ((βˆƒ a ∈ M_0.epsilon_arrow_list, a.start_state = p_0 ∧ List.map (Sum.inr ∘ Sum.inl) a.stop_state_list = stop_state_list) ∨ βˆƒ a ∈ M_0.accepting_state_list, a = p_0 ∧ List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = stop_state_list) ∧ Sum.inr (Sum.inl q_0) ∈ stop_state_list) ↔ βˆƒ stop_state_list, { start_state := p_0, stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q_0 ∈ stop_state_list
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 q_0 : Οƒ_0 ⊒ (βˆƒ stop_state_list, ((βˆƒ a ∈ M_0.epsilon_arrow_list, a.start_state = p_0 ∧ List.map (Sum.inr ∘ Sum.inl) a.stop_state_list = stop_state_list) ∨ βˆƒ a ∈ M_0.accepting_state_list, a = p_0 ∧ List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = stop_state_list) ∧ Sum.inr (Sum.inl q_0) ∈ stop_state_list) ↔ βˆƒ stop_state_list, { start_state := p_0, stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q_0 ∈ stop_state_list TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : Οƒ_1 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inl p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr (Sum.inr q_0) ∈ stop_state_list) = match (Sum.inr (Sum.inl p_0), Sum.inr (Sum.inr q_0)) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : Οƒ_1 ⊒ (βˆƒ stop_state_list, ((βˆƒ a ∈ M_0.epsilon_arrow_list, a.start_state = p_0 ∧ List.map (Sum.inr ∘ Sum.inl) a.stop_state_list = stop_state_list) ∨ βˆƒ a ∈ M_0.accepting_state_list, a = p_0 ∧ List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = stop_state_list) ∧ Sum.inr (Sum.inr q_0) ∈ stop_state_list) ↔ p_0 ∈ M_0.accepting_state_list ∧ q_0 ∈ M_1.starting_state_list
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : Οƒ_1 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inl p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr (Sum.inr q_0) ∈ stop_state_list) = match (Sum.inr (Sum.inl p_0), Sum.inr (Sum.inr q_0)) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
sorry
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : Οƒ_1 ⊒ (βˆƒ stop_state_list, ((βˆƒ a ∈ M_0.epsilon_arrow_list, a.start_state = p_0 ∧ List.map (Sum.inr ∘ Sum.inl) a.stop_state_list = stop_state_list) ∨ βˆƒ a ∈ M_0.accepting_state_list, a = p_0 ∧ List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = stop_state_list) ∧ Sum.inr (Sum.inr q_0) ∈ stop_state_list) ↔ p_0 ∈ M_0.accepting_state_list ∧ q_0 ∈ M_1.starting_state_list
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 q_0 : Οƒ_1 ⊒ (βˆƒ stop_state_list, ((βˆƒ a ∈ M_0.epsilon_arrow_list, a.start_state = p_0 ∧ List.map (Sum.inr ∘ Sum.inl) a.stop_state_list = stop_state_list) ∨ βˆƒ a ∈ M_0.accepting_state_list, a = p_0 ∧ List.map (Sum.inr ∘ Sum.inr) M_1.starting_state_list = stop_state_list) ∧ Sum.inr (Sum.inr q_0) ∈ stop_state_list) ↔ p_0 ∈ M_0.accepting_state_list ∧ q_0 ∈ M_1.starting_state_list TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
cases q
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 q : β„• βŠ• Οƒ_0 βŠ• Οƒ_1 p_0 : Οƒ_1 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inr p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ q ∈ stop_state_list) = match (Sum.inr (Sum.inr p_0), q) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False
case inl Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 val✝ : β„• ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inr p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inl val✝ ∈ stop_state_list) = match (Sum.inr (Sum.inr p_0), Sum.inl val✝) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False case inr Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 val✝ : Οƒ_0 βŠ• Οƒ_1 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inr p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr val✝ ∈ stop_state_list) = match (Sum.inr (Sum.inr p_0), Sum.inr val✝) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 q : β„• βŠ• Οƒ_0 βŠ• Οƒ_1 p_0 : Οƒ_1 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inr p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ q ∈ stop_state_list) = match (Sum.inr (Sum.inr p_0), q) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
case _ q_0 => simp intro xs x a1 a2 a3 simp only [← a3] simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : β„• ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inr p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inl q_0 ∈ stop_state_list) = match (Sum.inr (Sum.inr p_0), Sum.inl q_0) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : β„• ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inr p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inl q_0 ∈ stop_state_list) = match (Sum.inr (Sum.inr p_0), Sum.inl q_0) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
case _ q_0 => cases q_0 case _ q_0 => simp intro xs x a1 a2 a3 simp only [← a3] simp case _ q_0 => simp sorry
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : Οƒ_0 βŠ• Οƒ_1 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inr p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr q_0 ∈ stop_state_list) = match (Sum.inr (Sum.inr p_0), Sum.inr q_0) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : Οƒ_0 βŠ• Οƒ_1 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inr p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr q_0 ∈ stop_state_list) = match (Sum.inr (Sum.inr p_0), Sum.inr q_0) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : β„• ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inr p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inl q_0 ∈ stop_state_list) = match (Sum.inr (Sum.inr p_0), Sum.inl q_0) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : β„• ⊒ βˆ€ (x : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1)), βˆ€ x_1 ∈ M_1.epsilon_arrow_list, x_1.start_state = p_0 β†’ List.map (Sum.inr ∘ Sum.inr) x_1.stop_state_list = x β†’ Sum.inl q_0 βˆ‰ x
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : β„• ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inr p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inl q_0 ∈ stop_state_list) = match (Sum.inr (Sum.inr p_0), Sum.inl q_0) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
intro xs x a1 a2 a3
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : β„• ⊒ βˆ€ (x : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1)), βˆ€ x_1 ∈ M_1.epsilon_arrow_list, x_1.start_state = p_0 β†’ List.map (Sum.inr ∘ Sum.inr) x_1.stop_state_list = x β†’ Sum.inl q_0 βˆ‰ x
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : EpsilonArrow Οƒ_1 a1 : x ∈ M_1.epsilon_arrow_list a2 : x.start_state = p_0 a3 : List.map (Sum.inr ∘ Sum.inr) x.stop_state_list = xs ⊒ Sum.inl q_0 βˆ‰ xs
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : β„• ⊒ βˆ€ (x : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1)), βˆ€ x_1 ∈ M_1.epsilon_arrow_list, x_1.start_state = p_0 β†’ List.map (Sum.inr ∘ Sum.inr) x_1.stop_state_list = x β†’ Sum.inl q_0 βˆ‰ x TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
simp only [← a3]
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : EpsilonArrow Οƒ_1 a1 : x ∈ M_1.epsilon_arrow_list a2 : x.start_state = p_0 a3 : List.map (Sum.inr ∘ Sum.inr) x.stop_state_list = xs ⊒ Sum.inl q_0 βˆ‰ xs
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : EpsilonArrow Οƒ_1 a1 : x ∈ M_1.epsilon_arrow_list a2 : x.start_state = p_0 a3 : List.map (Sum.inr ∘ Sum.inr) x.stop_state_list = xs ⊒ Sum.inl q_0 βˆ‰ List.map (Sum.inr ∘ Sum.inr) x.stop_state_list
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : EpsilonArrow Οƒ_1 a1 : x ∈ M_1.epsilon_arrow_list a2 : x.start_state = p_0 a3 : List.map (Sum.inr ∘ Sum.inr) x.stop_state_list = xs ⊒ Sum.inl q_0 βˆ‰ xs TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : EpsilonArrow Οƒ_1 a1 : x ∈ M_1.epsilon_arrow_list a2 : x.start_state = p_0 a3 : List.map (Sum.inr ∘ Sum.inr) x.stop_state_list = xs ⊒ Sum.inl q_0 βˆ‰ List.map (Sum.inr ∘ Sum.inr) x.stop_state_list
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : β„• xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : EpsilonArrow Οƒ_1 a1 : x ∈ M_1.epsilon_arrow_list a2 : x.start_state = p_0 a3 : List.map (Sum.inr ∘ Sum.inr) x.stop_state_list = xs ⊒ Sum.inl q_0 βˆ‰ List.map (Sum.inr ∘ Sum.inr) x.stop_state_list TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
cases q_0
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : Οƒ_0 βŠ• Οƒ_1 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inr p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr q_0 ∈ stop_state_list) = match (Sum.inr (Sum.inr p_0), Sum.inr q_0) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False
case inl Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 val✝ : Οƒ_0 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inr p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr (Sum.inl val✝) ∈ stop_state_list) = match (Sum.inr (Sum.inr p_0), Sum.inr (Sum.inl val✝)) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False case inr Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 val✝ : Οƒ_1 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inr p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr (Sum.inr val✝) ∈ stop_state_list) = match (Sum.inr (Sum.inr p_0), Sum.inr (Sum.inr val✝)) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : Οƒ_0 βŠ• Οƒ_1 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inr p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr q_0 ∈ stop_state_list) = match (Sum.inr (Sum.inr p_0), Sum.inr q_0) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
case _ q_0 => simp intro xs x a1 a2 a3 simp only [← a3] simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : Οƒ_0 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inr p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr (Sum.inl q_0) ∈ stop_state_list) = match (Sum.inr (Sum.inr p_0), Sum.inr (Sum.inl q_0)) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : Οƒ_0 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inr p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr (Sum.inl q_0) ∈ stop_state_list) = match (Sum.inr (Sum.inr p_0), Sum.inr (Sum.inl q_0)) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
case _ q_0 => simp sorry
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 q_0 : Οƒ_1 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inr p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr (Sum.inr q_0) ∈ stop_state_list) = match (Sum.inr (Sum.inr p_0), Sum.inr (Sum.inr q_0)) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 q_0 : Οƒ_1 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inr p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr (Sum.inr q_0) ∈ stop_state_list) = match (Sum.inr (Sum.inr p_0), Sum.inr (Sum.inr q_0)) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : Οƒ_0 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inr p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr (Sum.inl q_0) ∈ stop_state_list) = match (Sum.inr (Sum.inr p_0), Sum.inr (Sum.inl q_0)) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : Οƒ_0 ⊒ βˆ€ (x : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1)), βˆ€ x_1 ∈ M_1.epsilon_arrow_list, x_1.start_state = p_0 β†’ List.map (Sum.inr ∘ Sum.inr) x_1.stop_state_list = x β†’ Sum.inr (Sum.inl q_0) βˆ‰ x
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : Οƒ_0 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inr p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr (Sum.inl q_0) ∈ stop_state_list) = match (Sum.inr (Sum.inr p_0), Sum.inr (Sum.inl q_0)) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
intro xs x a1 a2 a3
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : Οƒ_0 ⊒ βˆ€ (x : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1)), βˆ€ x_1 ∈ M_1.epsilon_arrow_list, x_1.start_state = p_0 β†’ List.map (Sum.inr ∘ Sum.inr) x_1.stop_state_list = x β†’ Sum.inr (Sum.inl q_0) βˆ‰ x
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : Οƒ_0 xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : EpsilonArrow Οƒ_1 a1 : x ∈ M_1.epsilon_arrow_list a2 : x.start_state = p_0 a3 : List.map (Sum.inr ∘ Sum.inr) x.stop_state_list = xs ⊒ Sum.inr (Sum.inl q_0) βˆ‰ xs
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : Οƒ_0 ⊒ βˆ€ (x : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1)), βˆ€ x_1 ∈ M_1.epsilon_arrow_list, x_1.start_state = p_0 β†’ List.map (Sum.inr ∘ Sum.inr) x_1.stop_state_list = x β†’ Sum.inr (Sum.inl q_0) βˆ‰ x TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
simp only [← a3]
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : Οƒ_0 xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : EpsilonArrow Οƒ_1 a1 : x ∈ M_1.epsilon_arrow_list a2 : x.start_state = p_0 a3 : List.map (Sum.inr ∘ Sum.inr) x.stop_state_list = xs ⊒ Sum.inr (Sum.inl q_0) βˆ‰ xs
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : Οƒ_0 xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : EpsilonArrow Οƒ_1 a1 : x ∈ M_1.epsilon_arrow_list a2 : x.start_state = p_0 a3 : List.map (Sum.inr ∘ Sum.inr) x.stop_state_list = xs ⊒ Sum.inr (Sum.inl q_0) βˆ‰ List.map (Sum.inr ∘ Sum.inr) x.stop_state_list
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : Οƒ_0 xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : EpsilonArrow Οƒ_1 a1 : x ∈ M_1.epsilon_arrow_list a2 : x.start_state = p_0 a3 : List.map (Sum.inr ∘ Sum.inr) x.stop_state_list = xs ⊒ Sum.inr (Sum.inl q_0) βˆ‰ xs TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : Οƒ_0 xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : EpsilonArrow Οƒ_1 a1 : x ∈ M_1.epsilon_arrow_list a2 : x.start_state = p_0 a3 : List.map (Sum.inr ∘ Sum.inr) x.stop_state_list = xs ⊒ Sum.inr (Sum.inl q_0) βˆ‰ List.map (Sum.inr ∘ Sum.inr) x.stop_state_list
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 q_0 : Οƒ_0 xs : List (β„• βŠ• Οƒ_0 βŠ• Οƒ_1) x : EpsilonArrow Οƒ_1 a1 : x ∈ M_1.epsilon_arrow_list a2 : x.start_state = p_0 a3 : List.map (Sum.inr ∘ Sum.inr) x.stop_state_list = xs ⊒ Sum.inr (Sum.inl q_0) βˆ‰ List.map (Sum.inr ∘ Sum.inr) x.stop_state_list TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 q_0 : Οƒ_1 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inr p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr (Sum.inr q_0) ∈ stop_state_list) = match (Sum.inr (Sum.inr p_0), Sum.inr (Sum.inr q_0)) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 q_0 : Οƒ_1 ⊒ (βˆƒ stop_state_list, (βˆƒ a ∈ M_1.epsilon_arrow_list, a.start_state = p_0 ∧ List.map (Sum.inr ∘ Sum.inr) a.stop_state_list = stop_state_list) ∧ Sum.inr (Sum.inr q_0) ∈ stop_state_list) ↔ βˆƒ stop_state_list, { start_state := p_0, stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q_0 ∈ stop_state_list
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 q_0 : Οƒ_1 ⊒ (βˆƒ stop_state_list, { start_state := Sum.inr (Sum.inr p_0), stop_state_list := stop_state_list } ∈ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inl arrow.start_state, stop_state_list := List.map Sum.inl arrow.stop_state_list }) M_0.epsilon_arrow_list) ++ List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) (List.map (fun arrow => { start_state := Sum.inr arrow.start_state, stop_state_list := List.map Sum.inr arrow.stop_state_list }) M_1.epsilon_arrow_list) ++ List.map (fun accepting_state => { start_state := accepting_state, stop_state_list := List.map Sum.inr (List.map Sum.inr M_1.starting_state_list) }) (List.map Sum.inr (List.map Sum.inl M_0.accepting_state_list)) ∧ Sum.inr (Sum.inr q_0) ∈ stop_state_list) = match (Sum.inr (Sum.inr p_0), Sum.inr (Sum.inr q_0)) with | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inl q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inr p'), Sum.inr (Sum.inr q')) => βˆƒ stop_state_list, { start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list | (Sum.inr (Sum.inl p'), Sum.inr (Sum.inr q')) => p' ∈ M_0.accepting_state_list ∧ q' ∈ M_1.starting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
sorry
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 q_0 : Οƒ_1 ⊒ (βˆƒ stop_state_list, (βˆƒ a ∈ M_1.epsilon_arrow_list, a.start_state = p_0 ∧ List.map (Sum.inr ∘ Sum.inr) a.stop_state_list = stop_state_list) ∧ Sum.inr (Sum.inr q_0) ∈ stop_state_list) ↔ βˆƒ stop_state_list, { start_state := p_0, stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q_0 ∈ stop_state_list
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 q_0 : Οƒ_1 ⊒ (βˆƒ stop_state_list, (βˆƒ a ∈ M_1.epsilon_arrow_list, a.start_state = p_0 ∧ List.map (Sum.inr ∘ Sum.inr) a.stop_state_list = stop_state_list) ∧ Sum.inr (Sum.inr q_0) ∈ stop_state_list) ↔ βˆƒ stop_state_list, { start_state := p_0, stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q_0 ∈ stop_state_list TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
constructor
case right.right Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 ⊒ ((fun state => state ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = fun p => match p with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False) ∧ (fun state => state ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = fun p => match p with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False
case right.right.left Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 ⊒ (fun state => state ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = fun p => match p with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False case right.right.right Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 ⊒ (fun state => state ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = fun p => match p with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False
Please generate a tactic in lean4 to solve the state. STATE: case right.right Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 ⊒ ((fun state => state ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = fun p => match p with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False) ∧ (fun state => state ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = fun p => match p with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
funext p
case right.right.left Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 ⊒ (fun state => state ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = fun p => match p with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False
case right.right.left.h Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p : β„• βŠ• Οƒ_0 βŠ• Οƒ_1 ⊒ (p ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = match p with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False
Please generate a tactic in lean4 to solve the state. STATE: case right.right.left Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 ⊒ (fun state => state ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = fun p => match p with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
cases p
case right.right.left.h Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p : β„• βŠ• Οƒ_0 βŠ• Οƒ_1 ⊒ (p ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = match p with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False
case right.right.left.h.inl Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 val✝ : β„• ⊒ (Sum.inl val✝ ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = match Sum.inl val✝ with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False case right.right.left.h.inr Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 val✝ : Οƒ_0 βŠ• Οƒ_1 ⊒ (Sum.inr val✝ ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = match Sum.inr val✝ with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False
Please generate a tactic in lean4 to solve the state. STATE: case right.right.left.h Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p : β„• βŠ• Οƒ_0 βŠ• Οƒ_1 ⊒ (p ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = match p with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
case _ p_0 => simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : β„• ⊒ (Sum.inl p_0 ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = match Sum.inl p_0 with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : β„• ⊒ (Sum.inl p_0 ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = match Sum.inl p_0 with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
case _ p_0 => cases p_0 case _ p_0 => simp case _ p_0 => simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 βŠ• Οƒ_1 ⊒ (Sum.inr p_0 ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = match Sum.inr p_0 with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 βŠ• Οƒ_1 ⊒ (Sum.inr p_0 ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = match Sum.inr p_0 with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : β„• ⊒ (Sum.inl p_0 ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = match Sum.inl p_0 with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : β„• ⊒ (Sum.inl p_0 ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = match Sum.inl p_0 with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
cases p_0
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 βŠ• Οƒ_1 ⊒ (Sum.inr p_0 ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = match Sum.inr p_0 with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False
case inl Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 val✝ : Οƒ_0 ⊒ (Sum.inr (Sum.inl val✝) ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = match Sum.inr (Sum.inl val✝) with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False case inr Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 val✝ : Οƒ_1 ⊒ (Sum.inr (Sum.inr val✝) ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = match Sum.inr (Sum.inr val✝) with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 βŠ• Οƒ_1 ⊒ (Sum.inr p_0 ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = match Sum.inr p_0 with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
case _ p_0 => simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 ⊒ (Sum.inr (Sum.inl p_0) ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = match Sum.inr (Sum.inl p_0) with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 ⊒ (Sum.inr (Sum.inl p_0) ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = match Sum.inr (Sum.inl p_0) with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
case _ p_0 => simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 ⊒ (Sum.inr (Sum.inr p_0) ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = match Sum.inr (Sum.inr p_0) with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 ⊒ (Sum.inr (Sum.inr p_0) ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = match Sum.inr (Sum.inr p_0) with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 ⊒ (Sum.inr (Sum.inl p_0) ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = match Sum.inr (Sum.inl p_0) with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 ⊒ (Sum.inr (Sum.inl p_0) ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = match Sum.inr (Sum.inl p_0) with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 ⊒ (Sum.inr (Sum.inr p_0) ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = match Sum.inr (Sum.inr p_0) with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 ⊒ (Sum.inr (Sum.inr p_0) ∈ List.map Sum.inr (List.map Sum.inl M_0.starting_state_list)) = match Sum.inr (Sum.inr p_0) with | Sum.inr (Sum.inl p') => p' ∈ M_0.starting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
funext p
case right.right.right Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 ⊒ (fun state => state ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = fun p => match p with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False
case right.right.right.h Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p : β„• βŠ• Οƒ_0 βŠ• Οƒ_1 ⊒ (p ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = match p with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False
Please generate a tactic in lean4 to solve the state. STATE: case right.right.right Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 ⊒ (fun state => state ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = fun p => match p with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
cases p
case right.right.right.h Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p : β„• βŠ• Οƒ_0 βŠ• Οƒ_1 ⊒ (p ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = match p with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False
case right.right.right.h.inl Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 val✝ : β„• ⊒ (Sum.inl val✝ ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = match Sum.inl val✝ with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False case right.right.right.h.inr Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 val✝ : Οƒ_0 βŠ• Οƒ_1 ⊒ (Sum.inr val✝ ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = match Sum.inr val✝ with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False
Please generate a tactic in lean4 to solve the state. STATE: case right.right.right.h Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p : β„• βŠ• Οƒ_0 βŠ• Οƒ_1 ⊒ (p ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = match p with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
case _ p_0 => simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : β„• ⊒ (Sum.inl p_0 ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = match Sum.inl p_0 with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : β„• ⊒ (Sum.inl p_0 ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = match Sum.inl p_0 with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
case _ p_0 => cases p_0 case _ p_0 => simp case _ p_0 => simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 βŠ• Οƒ_1 ⊒ (Sum.inr p_0 ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = match Sum.inr p_0 with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 βŠ• Οƒ_1 ⊒ (Sum.inr p_0 ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = match Sum.inr p_0 with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : β„• ⊒ (Sum.inl p_0 ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = match Sum.inl p_0 with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : β„• ⊒ (Sum.inl p_0 ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = match Sum.inl p_0 with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
cases p_0
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 βŠ• Οƒ_1 ⊒ (Sum.inr p_0 ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = match Sum.inr p_0 with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False
case inl Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 val✝ : Οƒ_0 ⊒ (Sum.inr (Sum.inl val✝) ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = match Sum.inr (Sum.inl val✝) with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False case inr Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 val✝ : Οƒ_1 ⊒ (Sum.inr (Sum.inr val✝) ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = match Sum.inr (Sum.inr val✝) with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 βŠ• Οƒ_1 ⊒ (Sum.inr p_0 ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = match Sum.inr p_0 with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
case _ p_0 => simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 ⊒ (Sum.inr (Sum.inl p_0) ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = match Sum.inr (Sum.inl p_0) with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 ⊒ (Sum.inr (Sum.inl p_0) ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = match Sum.inr (Sum.inl p_0) with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
case _ p_0 => simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 ⊒ (Sum.inr (Sum.inr p_0) ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = match Sum.inr (Sum.inr p_0) with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 ⊒ (Sum.inr (Sum.inr p_0) ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = match Sum.inr (Sum.inr p_0) with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 ⊒ (Sum.inr (Sum.inl p_0) ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = match Sum.inr (Sum.inl p_0) with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_0 ⊒ (Sum.inr (Sum.inl p_0) ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = match Sum.inr (Sum.inl p_0) with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/Parsing/RegExpToEpsilonNFA.lean
match_concat_EpsilonNFA_toAbstract
[557, 1]
[690, 19]
simp
Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 ⊒ (Sum.inr (Sum.inr p_0) ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = match Sum.inr (Sum.inr p_0) with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False
no goals
Please generate a tactic in lean4 to solve the state. STATE: Ξ± : Type inst✝ : DecidableEq Ξ± Οƒ_0 Οƒ_1 : Type M_0 : EpsilonNFA Ξ± Οƒ_0 M_1 : EpsilonNFA Ξ± Οƒ_1 p_0 : Οƒ_1 ⊒ (Sum.inr (Sum.inr p_0) ∈ List.map Sum.inr (List.map Sum.inr M_1.accepting_state_list)) = match Sum.inr (Sum.inr p_0) with | Sum.inr (Sum.inr p') => p' ∈ M_1.accepting_state_list | x => False TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.finset_var_name_max_len_mem
[23, 1]
[46, 18]
induction xs using Finset.induction_on
x : VarName xs : Finset VarName h1 : x ∈ xs ⊒ x.length ≀ finset_var_name_max_len xs
case empty x : VarName h1 : x ∈ βˆ… ⊒ x.length ≀ finset_var_name_max_len βˆ… case insert x a✝² : VarName s✝ : Finset VarName a✝¹ : a✝² βˆ‰ s✝ a✝ : x ∈ s✝ β†’ x.length ≀ finset_var_name_max_len s✝ h1 : x ∈ insert a✝² s✝ ⊒ x.length ≀ finset_var_name_max_len (insert a✝² s✝)
Please generate a tactic in lean4 to solve the state. STATE: x : VarName xs : Finset VarName h1 : x ∈ xs ⊒ x.length ≀ finset_var_name_max_len xs TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.finset_var_name_max_len_mem
[23, 1]
[46, 18]
case empty => simp at h1
x : VarName h1 : x ∈ βˆ… ⊒ x.length ≀ finset_var_name_max_len βˆ…
no goals
Please generate a tactic in lean4 to solve the state. STATE: x : VarName h1 : x ∈ βˆ… ⊒ x.length ≀ finset_var_name_max_len βˆ… TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.finset_var_name_max_len_mem
[23, 1]
[46, 18]
case insert hd tl a1 ih => simp at h1 cases h1 case inl c1 => subst c1 simp only [finset_var_name_max_len] simp case inr c1 => simp only [finset_var_name_max_len] at ih simp only [finset_var_name_max_len] simp right exact ih c1
x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ finset_var_name_max_len tl h1 : x ∈ insert hd tl ⊒ x.length ≀ finset_var_name_max_len (insert hd tl)
no goals
Please generate a tactic in lean4 to solve the state. STATE: x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ finset_var_name_max_len tl h1 : x ∈ insert hd tl ⊒ x.length ≀ finset_var_name_max_len (insert hd tl) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.finset_var_name_max_len_mem
[23, 1]
[46, 18]
simp at h1
x : VarName h1 : x ∈ βˆ… ⊒ x.length ≀ finset_var_name_max_len βˆ…
no goals
Please generate a tactic in lean4 to solve the state. STATE: x : VarName h1 : x ∈ βˆ… ⊒ x.length ≀ finset_var_name_max_len βˆ… TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.finset_var_name_max_len_mem
[23, 1]
[46, 18]
simp at h1
x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ finset_var_name_max_len tl h1 : x ∈ insert hd tl ⊒ x.length ≀ finset_var_name_max_len (insert hd tl)
x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ finset_var_name_max_len tl h1 : x = hd ∨ x ∈ tl ⊒ x.length ≀ finset_var_name_max_len (insert hd tl)
Please generate a tactic in lean4 to solve the state. STATE: x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ finset_var_name_max_len tl h1 : x ∈ insert hd tl ⊒ x.length ≀ finset_var_name_max_len (insert hd tl) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.finset_var_name_max_len_mem
[23, 1]
[46, 18]
cases h1
x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ finset_var_name_max_len tl h1 : x = hd ∨ x ∈ tl ⊒ x.length ≀ finset_var_name_max_len (insert hd tl)
case inl x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ finset_var_name_max_len tl h✝ : x = hd ⊒ x.length ≀ finset_var_name_max_len (insert hd tl) case inr x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ finset_var_name_max_len tl h✝ : x ∈ tl ⊒ x.length ≀ finset_var_name_max_len (insert hd tl)
Please generate a tactic in lean4 to solve the state. STATE: x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ finset_var_name_max_len tl h1 : x = hd ∨ x ∈ tl ⊒ x.length ≀ finset_var_name_max_len (insert hd tl) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.finset_var_name_max_len_mem
[23, 1]
[46, 18]
case inl c1 => subst c1 simp only [finset_var_name_max_len] simp
x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ finset_var_name_max_len tl c1 : x = hd ⊒ x.length ≀ finset_var_name_max_len (insert hd tl)
no goals
Please generate a tactic in lean4 to solve the state. STATE: x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ finset_var_name_max_len tl c1 : x = hd ⊒ x.length ≀ finset_var_name_max_len (insert hd tl) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.finset_var_name_max_len_mem
[23, 1]
[46, 18]
case inr c1 => simp only [finset_var_name_max_len] at ih simp only [finset_var_name_max_len] simp right exact ih c1
x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ finset_var_name_max_len tl c1 : x ∈ tl ⊒ x.length ≀ finset_var_name_max_len (insert hd tl)
no goals
Please generate a tactic in lean4 to solve the state. STATE: x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ finset_var_name_max_len tl c1 : x ∈ tl ⊒ x.length ≀ finset_var_name_max_len (insert hd tl) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.finset_var_name_max_len_mem
[23, 1]
[46, 18]
subst c1
x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ finset_var_name_max_len tl c1 : x = hd ⊒ x.length ≀ finset_var_name_max_len (insert hd tl)
x : VarName tl : Finset VarName ih : x ∈ tl β†’ x.length ≀ finset_var_name_max_len tl a1 : x βˆ‰ tl ⊒ x.length ≀ finset_var_name_max_len (insert x tl)
Please generate a tactic in lean4 to solve the state. STATE: x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ finset_var_name_max_len tl c1 : x = hd ⊒ x.length ≀ finset_var_name_max_len (insert hd tl) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.finset_var_name_max_len_mem
[23, 1]
[46, 18]
simp only [finset_var_name_max_len]
x : VarName tl : Finset VarName ih : x ∈ tl β†’ x.length ≀ finset_var_name_max_len tl a1 : x βˆ‰ tl ⊒ x.length ≀ finset_var_name_max_len (insert x tl)
x : VarName tl : Finset VarName ih : x ∈ tl β†’ x.length ≀ finset_var_name_max_len tl a1 : x βˆ‰ tl ⊒ x.length ≀ Finset.fold (fun m n => max m n) 0 (String.length ∘ VarName.toString) (insert x tl)
Please generate a tactic in lean4 to solve the state. STATE: x : VarName tl : Finset VarName ih : x ∈ tl β†’ x.length ≀ finset_var_name_max_len tl a1 : x βˆ‰ tl ⊒ x.length ≀ finset_var_name_max_len (insert x tl) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.finset_var_name_max_len_mem
[23, 1]
[46, 18]
simp
x : VarName tl : Finset VarName ih : x ∈ tl β†’ x.length ≀ finset_var_name_max_len tl a1 : x βˆ‰ tl ⊒ x.length ≀ Finset.fold (fun m n => max m n) 0 (String.length ∘ VarName.toString) (insert x tl)
no goals
Please generate a tactic in lean4 to solve the state. STATE: x : VarName tl : Finset VarName ih : x ∈ tl β†’ x.length ≀ finset_var_name_max_len tl a1 : x βˆ‰ tl ⊒ x.length ≀ Finset.fold (fun m n => max m n) 0 (String.length ∘ VarName.toString) (insert x tl) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.finset_var_name_max_len_mem
[23, 1]
[46, 18]
simp only [finset_var_name_max_len] at ih
x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ finset_var_name_max_len tl c1 : x ∈ tl ⊒ x.length ≀ finset_var_name_max_len (insert hd tl)
x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ Finset.fold (fun m n => max m n) 0 (String.length ∘ VarName.toString) tl c1 : x ∈ tl ⊒ x.length ≀ finset_var_name_max_len (insert hd tl)
Please generate a tactic in lean4 to solve the state. STATE: x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ finset_var_name_max_len tl c1 : x ∈ tl ⊒ x.length ≀ finset_var_name_max_len (insert hd tl) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.finset_var_name_max_len_mem
[23, 1]
[46, 18]
simp only [finset_var_name_max_len]
x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ Finset.fold (fun m n => max m n) 0 (String.length ∘ VarName.toString) tl c1 : x ∈ tl ⊒ x.length ≀ finset_var_name_max_len (insert hd tl)
x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ Finset.fold (fun m n => max m n) 0 (String.length ∘ VarName.toString) tl c1 : x ∈ tl ⊒ x.length ≀ Finset.fold (fun m n => max m n) 0 (String.length ∘ VarName.toString) (insert hd tl)
Please generate a tactic in lean4 to solve the state. STATE: x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ Finset.fold (fun m n => max m n) 0 (String.length ∘ VarName.toString) tl c1 : x ∈ tl ⊒ x.length ≀ finset_var_name_max_len (insert hd tl) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.finset_var_name_max_len_mem
[23, 1]
[46, 18]
simp
x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ Finset.fold (fun m n => max m n) 0 (String.length ∘ VarName.toString) tl c1 : x ∈ tl ⊒ x.length ≀ Finset.fold (fun m n => max m n) 0 (String.length ∘ VarName.toString) (insert hd tl)
x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ Finset.fold (fun m n => max m n) 0 (String.length ∘ VarName.toString) tl c1 : x ∈ tl ⊒ x.length ≀ hd.length ∨ x.length ≀ Finset.fold (fun m n => max m n) 0 (fun x => x.length) tl
Please generate a tactic in lean4 to solve the state. STATE: x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ Finset.fold (fun m n => max m n) 0 (String.length ∘ VarName.toString) tl c1 : x ∈ tl ⊒ x.length ≀ Finset.fold (fun m n => max m n) 0 (String.length ∘ VarName.toString) (insert hd tl) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.finset_var_name_max_len_mem
[23, 1]
[46, 18]
right
x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ Finset.fold (fun m n => max m n) 0 (String.length ∘ VarName.toString) tl c1 : x ∈ tl ⊒ x.length ≀ hd.length ∨ x.length ≀ Finset.fold (fun m n => max m n) 0 (fun x => x.length) tl
case h x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ Finset.fold (fun m n => max m n) 0 (String.length ∘ VarName.toString) tl c1 : x ∈ tl ⊒ x.length ≀ Finset.fold (fun m n => max m n) 0 (fun x => x.length) tl
Please generate a tactic in lean4 to solve the state. STATE: x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ Finset.fold (fun m n => max m n) 0 (String.length ∘ VarName.toString) tl c1 : x ∈ tl ⊒ x.length ≀ hd.length ∨ x.length ≀ Finset.fold (fun m n => max m n) 0 (fun x => x.length) tl TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.finset_var_name_max_len_mem
[23, 1]
[46, 18]
exact ih c1
case h x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ Finset.fold (fun m n => max m n) 0 (String.length ∘ VarName.toString) tl c1 : x ∈ tl ⊒ x.length ≀ Finset.fold (fun m n => max m n) 0 (fun x => x.length) tl
no goals
Please generate a tactic in lean4 to solve the state. STATE: case h x hd : VarName tl : Finset VarName a1 : hd βˆ‰ tl ih : x ∈ tl β†’ x.length ≀ Finset.fold (fun m n => max m n) 0 (String.length ∘ VarName.toString) tl c1 : x ∈ tl ⊒ x.length ≀ Finset.fold (fun m n => max m n) 0 (fun x => x.length) tl TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.fresh_not_mem
[69, 1]
[91, 59]
obtain s1 := finset_var_name_max_len_mem x xs h
x : VarName c : Char xs : Finset VarName h : x ∈ xs ⊒ finset_var_name_max_len xs - x.length < finset_var_name_max_len xs + 1 - x.length
x : VarName c : Char xs : Finset VarName h : x ∈ xs s1 : x.length ≀ finset_var_name_max_len xs ⊒ finset_var_name_max_len xs - x.length < finset_var_name_max_len xs + 1 - x.length
Please generate a tactic in lean4 to solve the state. STATE: x : VarName c : Char xs : Finset VarName h : x ∈ xs ⊒ finset_var_name_max_len xs - x.length < finset_var_name_max_len xs + 1 - x.length TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.fresh_not_mem
[69, 1]
[91, 59]
simp only [tsub_lt_tsub_iff_right s1]
x : VarName c : Char xs : Finset VarName h : x ∈ xs s1 : x.length ≀ finset_var_name_max_len xs ⊒ finset_var_name_max_len xs - x.length < finset_var_name_max_len xs + 1 - x.length
x : VarName c : Char xs : Finset VarName h : x ∈ xs s1 : x.length ≀ finset_var_name_max_len xs ⊒ finset_var_name_max_len xs < finset_var_name_max_len xs + 1
Please generate a tactic in lean4 to solve the state. STATE: x : VarName c : Char xs : Finset VarName h : x ∈ xs s1 : x.length ≀ finset_var_name_max_len xs ⊒ finset_var_name_max_len xs - x.length < finset_var_name_max_len xs + 1 - x.length TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.fresh_not_mem
[69, 1]
[91, 59]
simp
x : VarName c : Char xs : Finset VarName h : x ∈ xs s1 : x.length ≀ finset_var_name_max_len xs ⊒ finset_var_name_max_len xs < finset_var_name_max_len xs + 1
no goals
Please generate a tactic in lean4 to solve the state. STATE: x : VarName c : Char xs : Finset VarName h : x ∈ xs s1 : x.length ≀ finset_var_name_max_len xs ⊒ finset_var_name_max_len xs < finset_var_name_max_len xs + 1 TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.fresh_not_mem
[69, 1]
[91, 59]
unfold fresh
x : VarName c : Char xs : Finset VarName h : x ∈ xs this : finset_var_name_max_len xs - x.length < finset_var_name_max_len xs + 1 - x.length ⊒ fresh x c xs βˆ‰ xs
x : VarName c : Char xs : Finset VarName h : x ∈ xs this : finset_var_name_max_len xs - x.length < finset_var_name_max_len xs + 1 - x.length ⊒ (if h : x ∈ xs then let_fun this := β‹―; fresh { toString := x.toString ++ c.toString } c xs else x) βˆ‰ xs
Please generate a tactic in lean4 to solve the state. STATE: x : VarName c : Char xs : Finset VarName h : x ∈ xs this : finset_var_name_max_len xs - x.length < finset_var_name_max_len xs + 1 - x.length ⊒ fresh x c xs βˆ‰ xs TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.fresh_not_mem
[69, 1]
[91, 59]
simp
x : VarName c : Char xs : Finset VarName h : x ∈ xs this : finset_var_name_max_len xs - x.length < finset_var_name_max_len xs + 1 - x.length ⊒ (if h : x ∈ xs then let_fun this := β‹―; fresh { toString := x.toString ++ c.toString } c xs else x) βˆ‰ xs
x : VarName c : Char xs : Finset VarName h : x ∈ xs this : finset_var_name_max_len xs - x.length < finset_var_name_max_len xs + 1 - x.length ⊒ (if x ∈ xs then fresh { toString := x.toString ++ c.toString } c xs else x) βˆ‰ xs
Please generate a tactic in lean4 to solve the state. STATE: x : VarName c : Char xs : Finset VarName h : x ∈ xs this : finset_var_name_max_len xs - x.length < finset_var_name_max_len xs + 1 - x.length ⊒ (if h : x ∈ xs then let_fun this := β‹―; fresh { toString := x.toString ++ c.toString } c xs else x) βˆ‰ xs TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.fresh_not_mem
[69, 1]
[91, 59]
simp only [if_pos h]
x : VarName c : Char xs : Finset VarName h : x ∈ xs this : finset_var_name_max_len xs - x.length < finset_var_name_max_len xs + 1 - x.length ⊒ (if x ∈ xs then fresh { toString := x.toString ++ c.toString } c xs else x) βˆ‰ xs
x : VarName c : Char xs : Finset VarName h : x ∈ xs this : finset_var_name_max_len xs - x.length < finset_var_name_max_len xs + 1 - x.length ⊒ fresh { toString := x.toString ++ c.toString } c xs βˆ‰ xs
Please generate a tactic in lean4 to solve the state. STATE: x : VarName c : Char xs : Finset VarName h : x ∈ xs this : finset_var_name_max_len xs - x.length < finset_var_name_max_len xs + 1 - x.length ⊒ (if x ∈ xs then fresh { toString := x.toString ++ c.toString } c xs else x) βˆ‰ xs TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.fresh_not_mem
[69, 1]
[91, 59]
apply fresh_not_mem
x : VarName c : Char xs : Finset VarName h : x ∈ xs this : finset_var_name_max_len xs - x.length < finset_var_name_max_len xs + 1 - x.length ⊒ fresh { toString := x.toString ++ c.toString } c xs βˆ‰ xs
no goals
Please generate a tactic in lean4 to solve the state. STATE: x : VarName c : Char xs : Finset VarName h : x ∈ xs this : finset_var_name_max_len xs - x.length < finset_var_name_max_len xs + 1 - x.length ⊒ fresh { toString := x.toString ++ c.toString } c xs βˆ‰ xs TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.fresh_not_mem
[69, 1]
[91, 59]
unfold fresh
x : VarName c : Char xs : Finset VarName h : x βˆ‰ xs ⊒ fresh x c xs βˆ‰ xs
x : VarName c : Char xs : Finset VarName h : x βˆ‰ xs ⊒ (if h : x ∈ xs then let_fun this := β‹―; fresh { toString := x.toString ++ c.toString } c xs else x) βˆ‰ xs
Please generate a tactic in lean4 to solve the state. STATE: x : VarName c : Char xs : Finset VarName h : x βˆ‰ xs ⊒ fresh x c xs βˆ‰ xs TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.fresh_not_mem
[69, 1]
[91, 59]
simp
x : VarName c : Char xs : Finset VarName h : x βˆ‰ xs ⊒ (if h : x ∈ xs then let_fun this := β‹―; fresh { toString := x.toString ++ c.toString } c xs else x) βˆ‰ xs
x : VarName c : Char xs : Finset VarName h : x βˆ‰ xs ⊒ (if x ∈ xs then fresh { toString := x.toString ++ c.toString } c xs else x) βˆ‰ xs
Please generate a tactic in lean4 to solve the state. STATE: x : VarName c : Char xs : Finset VarName h : x βˆ‰ xs ⊒ (if h : x ∈ xs then let_fun this := β‹―; fresh { toString := x.toString ++ c.toString } c xs else x) βˆ‰ xs TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.fresh_not_mem
[69, 1]
[91, 59]
simp [if_neg h]
x : VarName c : Char xs : Finset VarName h : x βˆ‰ xs ⊒ (if x ∈ xs then fresh { toString := x.toString ++ c.toString } c xs else x) βˆ‰ xs
x : VarName c : Char xs : Finset VarName h : x βˆ‰ xs ⊒ x βˆ‰ xs
Please generate a tactic in lean4 to solve the state. STATE: x : VarName c : Char xs : Finset VarName h : x βˆ‰ xs ⊒ (if x ∈ xs then fresh { toString := x.toString ++ c.toString } c xs else x) βˆ‰ xs TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Fresh.lean
FOL.NV.fresh_not_mem
[69, 1]
[91, 59]
exact h
x : VarName c : Char xs : Finset VarName h : x βˆ‰ xs ⊒ x βˆ‰ xs
no goals
Please generate a tactic in lean4 to solve the state. STATE: x : VarName c : Char xs : Finset VarName h : x βˆ‰ xs ⊒ x βˆ‰ xs TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
[90, 1]
[226, 15]
induction F generalizing binders V
D : Type I : Interpretation D V V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) binders : Finset VarName F : Formula h1 : admitsAux Ο„ binders F h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E F ↔ Holds D I V E (replace c Ο„ F)
case pred_const_ D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) a✝¹ : PredName a✝ : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders (pred_const_ a✝¹ a✝) h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (pred_const_ a✝¹ a✝) ↔ Holds D I V E (replace c Ο„ (pred_const_ a✝¹ a✝)) case pred_var_ D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) a✝¹ : PredName a✝ : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders (pred_var_ a✝¹ a✝) h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (pred_var_ a✝¹ a✝) ↔ Holds D I V E (replace c Ο„ (pred_var_ a✝¹ a✝)) case eq_ D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) a✝¹ a✝ : VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders (eq_ a✝¹ a✝) h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (eq_ a✝¹ a✝) ↔ Holds D I V E (replace c Ο„ (eq_ a✝¹ a✝)) case true_ D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders true_ h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E true_ ↔ Holds D I V E (replace c Ο„ true_) case false_ D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders false_ h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E false_ ↔ Holds D I V E (replace c Ο„ false_) case not_ D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) a✝ : Formula a_ih✝ : βˆ€ (V : VarAssignment D) (binders : Finset VarName), admitsAux Ο„ binders a✝ β†’ (βˆ€ x βˆ‰ binders, V' x = V x) β†’ (Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E a✝ ↔ Holds D I V E (replace c Ο„ a✝)) V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders a✝.not_ h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E a✝.not_ ↔ Holds D I V E (replace c Ο„ a✝.not_) case imp_ D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) a✝¹ a✝ : Formula a_ih✝¹ : βˆ€ (V : VarAssignment D) (binders : Finset VarName), admitsAux Ο„ binders a✝¹ β†’ (βˆ€ x βˆ‰ binders, V' x = V x) β†’ (Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E a✝¹ ↔ Holds D I V E (replace c Ο„ a✝¹)) a_ih✝ : βˆ€ (V : VarAssignment D) (binders : Finset VarName), admitsAux Ο„ binders a✝ β†’ (βˆ€ x βˆ‰ binders, V' x = V x) β†’ (Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E a✝ ↔ Holds D I V E (replace c Ο„ a✝)) V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders (a✝¹.imp_ a✝) h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (a✝¹.imp_ a✝) ↔ Holds D I V E (replace c Ο„ (a✝¹.imp_ a✝)) case and_ D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) a✝¹ a✝ : Formula a_ih✝¹ : βˆ€ (V : VarAssignment D) (binders : Finset VarName), admitsAux Ο„ binders a✝¹ β†’ (βˆ€ x βˆ‰ binders, V' x = V x) β†’ (Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E a✝¹ ↔ Holds D I V E (replace c Ο„ a✝¹)) a_ih✝ : βˆ€ (V : VarAssignment D) (binders : Finset VarName), admitsAux Ο„ binders a✝ β†’ (βˆ€ x βˆ‰ binders, V' x = V x) β†’ (Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E a✝ ↔ Holds D I V E (replace c Ο„ a✝)) V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders (a✝¹.and_ a✝) h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (a✝¹.and_ a✝) ↔ Holds D I V E (replace c Ο„ (a✝¹.and_ a✝)) case or_ D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) a✝¹ a✝ : Formula a_ih✝¹ : βˆ€ (V : VarAssignment D) (binders : Finset VarName), admitsAux Ο„ binders a✝¹ β†’ (βˆ€ x βˆ‰ binders, V' x = V x) β†’ (Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E a✝¹ ↔ Holds D I V E (replace c Ο„ a✝¹)) a_ih✝ : βˆ€ (V : VarAssignment D) (binders : Finset VarName), admitsAux Ο„ binders a✝ β†’ (βˆ€ x βˆ‰ binders, V' x = V x) β†’ (Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E a✝ ↔ Holds D I V E (replace c Ο„ a✝)) V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders (a✝¹.or_ a✝) h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (a✝¹.or_ a✝) ↔ Holds D I V E (replace c Ο„ (a✝¹.or_ a✝)) case iff_ D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) a✝¹ a✝ : Formula a_ih✝¹ : βˆ€ (V : VarAssignment D) (binders : Finset VarName), admitsAux Ο„ binders a✝¹ β†’ (βˆ€ x βˆ‰ binders, V' x = V x) β†’ (Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E a✝¹ ↔ Holds D I V E (replace c Ο„ a✝¹)) a_ih✝ : βˆ€ (V : VarAssignment D) (binders : Finset VarName), admitsAux Ο„ binders a✝ β†’ (βˆ€ x βˆ‰ binders, V' x = V x) β†’ (Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E a✝ ↔ Holds D I V E (replace c Ο„ a✝)) V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders (a✝¹.iff_ a✝) h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (a✝¹.iff_ a✝) ↔ Holds D I V E (replace c Ο„ (a✝¹.iff_ a✝)) case forall_ D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) a✝¹ : VarName a✝ : Formula a_ih✝ : βˆ€ (V : VarAssignment D) (binders : Finset VarName), admitsAux Ο„ binders a✝ β†’ (βˆ€ x βˆ‰ binders, V' x = V x) β†’ (Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E a✝ ↔ Holds D I V E (replace c Ο„ a✝)) V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders (forall_ a✝¹ a✝) h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (forall_ a✝¹ a✝) ↔ Holds D I V E (replace c Ο„ (forall_ a✝¹ a✝)) case exists_ D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) a✝¹ : VarName a✝ : Formula a_ih✝ : βˆ€ (V : VarAssignment D) (binders : Finset VarName), admitsAux Ο„ binders a✝ β†’ (βˆ€ x βˆ‰ binders, V' x = V x) β†’ (Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E a✝ ↔ Holds D I V E (replace c Ο„ a✝)) V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders (exists_ a✝¹ a✝) h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (exists_ a✝¹ a✝) ↔ Holds D I V E (replace c Ο„ (exists_ a✝¹ a✝)) case def_ D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) a✝¹ : DefName a✝ : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders (def_ a✝¹ a✝) h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (def_ a✝¹ a✝) ↔ Holds D I V E (replace c Ο„ (def_ a✝¹ a✝))
Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) binders : Finset VarName F : Formula h1 : admitsAux Ο„ binders F h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E F ↔ Holds D I V E (replace c Ο„ F) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
[90, 1]
[226, 15]
case pred_const_ X xs => simp only [replace] simp only [Holds]
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders (pred_const_ X xs) h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (pred_const_ X xs) ↔ Holds D I V E (replace c Ο„ (pred_const_ X xs))
no goals
Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders (pred_const_ X xs) h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (pred_const_ X xs) ↔ Holds D I V E (replace c Ο„ (pred_const_ X xs)) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
[90, 1]
[226, 15]
case eq_ x y => simp only [replace] simp only [Holds]
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) x y : VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders (eq_ x y) h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (eq_ x y) ↔ Holds D I V E (replace c Ο„ (eq_ x y))
no goals
Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) x y : VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders (eq_ x y) h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (eq_ x y) ↔ Holds D I V E (replace c Ο„ (eq_ x y)) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
[90, 1]
[226, 15]
case true_ | false_ => simp only [replace] simp only [Holds]
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders false_ h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E false_ ↔ Holds D I V E (replace c Ο„ false_)
no goals
Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders false_ h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E false_ ↔ Holds D I V E (replace c Ο„ false_) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
[90, 1]
[226, 15]
case not_ phi phi_ih => simp only [admitsAux] at h1 simp only [replace] simp only [Holds] congr! 1 exact phi_ih V binders h1 h2
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) phi : Formula phi_ih : βˆ€ (V : VarAssignment D) (binders : Finset VarName), admitsAux Ο„ binders phi β†’ (βˆ€ x βˆ‰ binders, V' x = V x) β†’ (Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c Ο„ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders phi.not_ h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi.not_ ↔ Holds D I V E (replace c Ο„ phi.not_)
no goals
Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) phi : Formula phi_ih : βˆ€ (V : VarAssignment D) (binders : Finset VarName), admitsAux Ο„ binders phi β†’ (βˆ€ x βˆ‰ binders, V' x = V x) β†’ (Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c Ο„ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders phi.not_ h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi.not_ ↔ Holds D I V E (replace c Ο„ phi.not_) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
[90, 1]
[226, 15]
case forall_ x phi phi_ih | exists_ x phi phi_ih => simp only [admitsAux] at h1 simp only [replace] simp only [Holds] first | apply forall_congr' | apply exists_congr intro d apply phi_ih (Function.updateITE V x d) (binders βˆͺ {x}) h1 intro v a1 simp only [Function.updateITE] simp at a1 push_neg at a1 cases a1 case h.intro a1_left a1_right => simp only [if_neg a1_right] exact h2 v a1_left
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) x : VarName phi : Formula phi_ih : βˆ€ (V : VarAssignment D) (binders : Finset VarName), admitsAux Ο„ binders phi β†’ (βˆ€ x βˆ‰ binders, V' x = V x) β†’ (Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c Ο„ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders (exists_ x phi) h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (exists_ x phi) ↔ Holds D I V E (replace c Ο„ (exists_ x phi))
no goals
Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) x : VarName phi : Formula phi_ih : βˆ€ (V : VarAssignment D) (binders : Finset VarName), admitsAux Ο„ binders phi β†’ (βˆ€ x βˆ‰ binders, V' x = V x) β†’ (Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E phi ↔ Holds D I V E (replace c Ο„ phi)) V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders (exists_ x phi) h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (exists_ x phi) ↔ Holds D I V E (replace c Ο„ (exists_ x phi)) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
[90, 1]
[226, 15]
simp only [replace]
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders (pred_const_ X xs) h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (pred_const_ X xs) ↔ Holds D I V E (replace c Ο„ (pred_const_ X xs))
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders (pred_const_ X xs) h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (Ο„ X ds.length).isSome = true then if ds.length = ((Ο„ X ds.length).get β‹―).1.length then Holds D I (Function.updateListITE V' ((Ο„ X ds.length).get β‹―).1 ds) E ((Ο„ X ds.length).get β‹―).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E (pred_const_ X xs) ↔ Holds D I V E (pred_const_ X xs)
Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders (pred_const_ X xs) h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (pred_const_ X xs) ↔ Holds D I V E (replace c Ο„ (pred_const_ X xs)) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
[90, 1]
[226, 15]
simp only [Holds]
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders (pred_const_ X xs) h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (Ο„ X ds.length).isSome = true then if ds.length = ((Ο„ X ds.length).get β‹―).1.length then Holds D I (Function.updateListITE V' ((Ο„ X ds.length).get β‹―).1 ds) E ((Ο„ X ds.length).get β‹―).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E (pred_const_ X xs) ↔ Holds D I V E (pred_const_ X xs)
no goals
Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders (pred_const_ X xs) h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (Ο„ X ds.length).isSome = true then if ds.length = ((Ο„ X ds.length).get β‹―).1.length then Holds D I (Function.updateListITE V' ((Ο„ X ds.length).get β‹―).1 ds) E ((Ο„ X ds.length).get β‹―).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E (pred_const_ X xs) ↔ Holds D I V E (pred_const_ X xs) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
[90, 1]
[226, 15]
simp only [admitsAux] at h1
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders (pred_var_ X xs) h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (pred_var_ X xs) ↔ Holds D I V E (replace c Ο„ (pred_var_ X xs))
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then if xs.length = ((Ο„ X xs.length).get β‹―).1.length then binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True else True ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (pred_var_ X xs) ↔ Holds D I V E (replace c Ο„ (pred_var_ X xs))
Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h1 : admitsAux Ο„ binders (pred_var_ X xs) h2 : βˆ€ x βˆ‰ binders, V' x = V x ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (pred_var_ X xs) ↔ Holds D I V E (replace c Ο„ (pred_var_ X xs)) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
[90, 1]
[226, 15]
simp at h1
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then if xs.length = ((Ο„ X xs.length).get β‹―).1.length then binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True else True ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (pred_var_ X xs) ↔ Holds D I V E (replace c Ο„ (pred_var_ X xs))
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (pred_var_ X xs) ↔ Holds D I V E (replace c Ο„ (pred_var_ X xs))
Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then if xs.length = ((Ο„ X xs.length).get β‹―).1.length then binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True else True ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (pred_var_ X xs) ↔ Holds D I V E (replace c Ο„ (pred_var_ X xs)) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
[90, 1]
[226, 15]
simp only [replace]
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (pred_var_ X xs) ↔ Holds D I V E (replace c Ο„ (pred_var_ X xs))
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (Ο„ X ds.length).isSome = true then if ds.length = ((Ο„ X ds.length).get β‹―).1.length then Holds D I (Function.updateListITE V' ((Ο„ X ds.length).get β‹―).1 ds) E ((Ο„ X ds.length).get β‹―).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E (pred_var_ X xs) ↔ Holds D I V E (if h : (Ο„ X xs.length).isSome = true then if xs.length = ((Ο„ X xs.length).get β‹―).1.length then Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο„ X xs.length).get β‹―).1 xs) c ((Ο„ X xs.length).get β‹―).2 else pred_var_ X xs else pred_var_ X xs)
Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => let opt := Ο„ X ds.length; if h : opt.isSome = true then let val := opt.get h; let zs := val.1; let H := val.2; if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds else I.pred_var_ X ds } V E (pred_var_ X xs) ↔ Holds D I V E (replace c Ο„ (pred_var_ X xs)) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
[90, 1]
[226, 15]
simp only [Holds]
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (Ο„ X ds.length).isSome = true then if ds.length = ((Ο„ X ds.length).get β‹―).1.length then Holds D I (Function.updateListITE V' ((Ο„ X ds.length).get β‹―).1 ds) E ((Ο„ X ds.length).get β‹―).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E (pred_var_ X xs) ↔ Holds D I V E (if h : (Ο„ X xs.length).isSome = true then if xs.length = ((Ο„ X xs.length).get β‹―).1.length then Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο„ X xs.length).get β‹―).1 xs) c ((Ο„ X xs.length).get β‹―).2 else pred_var_ X xs else pred_var_ X xs)
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True ⊒ (if h : (Ο„ X (List.map V xs).length).isSome = true then if (List.map V xs).length = ((Ο„ X (List.map V xs).length).get β‹―).1.length then Holds D I (Function.updateListITE V' ((Ο„ X (List.map V xs).length).get β‹―).1 (List.map V xs)) E ((Ο„ X (List.map V xs).length).get β‹―).2 else I.pred_var_ X (List.map V xs) else I.pred_var_ X (List.map V xs)) ↔ Holds D I V E (if h : (Ο„ X xs.length).isSome = true then if xs.length = ((Ο„ X xs.length).get β‹―).1.length then Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο„ X xs.length).get β‹―).1 xs) c ((Ο„ X xs.length).get β‹―).2 else pred_var_ X xs else pred_var_ X xs)
Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True ⊒ Holds D { nonempty := β‹―, pred_const_ := I.pred_const_, pred_var_ := fun X ds => if h : (Ο„ X ds.length).isSome = true then if ds.length = ((Ο„ X ds.length).get β‹―).1.length then Holds D I (Function.updateListITE V' ((Ο„ X ds.length).get β‹―).1 ds) E ((Ο„ X ds.length).get β‹―).2 else I.pred_var_ X ds else I.pred_var_ X ds } V E (pred_var_ X xs) ↔ Holds D I V E (if h : (Ο„ X xs.length).isSome = true then if xs.length = ((Ο„ X xs.length).get β‹―).1.length then Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο„ X xs.length).get β‹―).1 xs) c ((Ο„ X xs.length).get β‹―).2 else pred_var_ X xs else pred_var_ X xs) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
[90, 1]
[226, 15]
simp
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True ⊒ (if h : (Ο„ X (List.map V xs).length).isSome = true then if (List.map V xs).length = ((Ο„ X (List.map V xs).length).get β‹―).1.length then Holds D I (Function.updateListITE V' ((Ο„ X (List.map V xs).length).get β‹―).1 (List.map V xs)) E ((Ο„ X (List.map V xs).length).get β‹―).2 else I.pred_var_ X (List.map V xs) else I.pred_var_ X (List.map V xs)) ↔ Holds D I V E (if h : (Ο„ X xs.length).isSome = true then if xs.length = ((Ο„ X xs.length).get β‹―).1.length then Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο„ X xs.length).get β‹―).1 xs) c ((Ο„ X xs.length).get β‹―).2 else pred_var_ X xs else pred_var_ X xs)
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True ⊒ (if h : (Ο„ X xs.length).isSome = true then if xs.length = ((Ο„ X xs.length).get β‹―).1.length then Holds D I (Function.updateListITE V' ((Ο„ X xs.length).get β‹―).1 (List.map V xs)) E ((Ο„ X xs.length).get β‹―).2 else I.pred_var_ X (List.map V xs) else I.pred_var_ X (List.map V xs)) ↔ Holds D I V E (if h : (Ο„ X xs.length).isSome = true then if xs.length = ((Ο„ X xs.length).get β‹―).1.length then Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο„ X xs.length).get β‹―).1 xs) c ((Ο„ X xs.length).get β‹―).2 else pred_var_ X xs else pred_var_ X xs)
Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True ⊒ (if h : (Ο„ X (List.map V xs).length).isSome = true then if (List.map V xs).length = ((Ο„ X (List.map V xs).length).get β‹―).1.length then Holds D I (Function.updateListITE V' ((Ο„ X (List.map V xs).length).get β‹―).1 (List.map V xs)) E ((Ο„ X (List.map V xs).length).get β‹―).2 else I.pred_var_ X (List.map V xs) else I.pred_var_ X (List.map V xs)) ↔ Holds D I V E (if h : (Ο„ X xs.length).isSome = true then if xs.length = ((Ο„ X xs.length).get β‹―).1.length then Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο„ X xs.length).get β‹―).1 xs) c ((Ο„ X xs.length).get β‹―).2 else pred_var_ X xs else pred_var_ X xs) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
[90, 1]
[226, 15]
split_ifs
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True ⊒ (if h : (Ο„ X xs.length).isSome = true then if xs.length = ((Ο„ X xs.length).get β‹―).1.length then Holds D I (Function.updateListITE V' ((Ο„ X xs.length).get β‹―).1 (List.map V xs)) E ((Ο„ X xs.length).get β‹―).2 else I.pred_var_ X (List.map V xs) else I.pred_var_ X (List.map V xs)) ↔ Holds D I V E (if h : (Ο„ X xs.length).isSome = true then if xs.length = ((Ο„ X xs.length).get β‹―).1.length then Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο„ X xs.length).get β‹―).1 xs) c ((Ο„ X xs.length).get β‹―).2 else pred_var_ X xs else pred_var_ X xs)
case pos D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True h✝¹ : (Ο„ X xs.length).isSome = true h✝ : xs.length = ((Ο„ X xs.length).get β‹―).1.length ⊒ Holds D I (Function.updateListITE V' ((Ο„ X xs.length).get β‹―).1 (List.map V xs)) E ((Ο„ X xs.length).get β‹―).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο„ X xs.length).get β‹―).1 xs) c ((Ο„ X xs.length).get β‹―).2) case neg D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True h✝¹ : (Ο„ X xs.length).isSome = true h✝ : Β¬xs.length = ((Ο„ X xs.length).get β‹―).1.length ⊒ I.pred_var_ X (List.map V xs) ↔ Holds D I V E (pred_var_ X xs) case neg D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True h✝ : Β¬(Ο„ X xs.length).isSome = true ⊒ I.pred_var_ X (List.map V xs) ↔ Holds D I V E (pred_var_ X xs)
Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True ⊒ (if h : (Ο„ X xs.length).isSome = true then if xs.length = ((Ο„ X xs.length).get β‹―).1.length then Holds D I (Function.updateListITE V' ((Ο„ X xs.length).get β‹―).1 (List.map V xs)) E ((Ο„ X xs.length).get β‹―).2 else I.pred_var_ X (List.map V xs) else I.pred_var_ X (List.map V xs)) ↔ Holds D I V E (if h : (Ο„ X xs.length).isSome = true then if xs.length = ((Ο„ X xs.length).get β‹―).1.length then Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο„ X xs.length).get β‹―).1 xs) c ((Ο„ X xs.length).get β‹―).2 else pred_var_ X xs else pred_var_ X xs) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
[90, 1]
[226, 15]
case _ c1 c2 => simp only [Holds]
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True c1 : (Ο„ X xs.length).isSome = true c2 : Β¬xs.length = ((Ο„ X xs.length).get β‹―).1.length ⊒ I.pred_var_ X (List.map V xs) ↔ Holds D I V E (pred_var_ X xs)
no goals
Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True c1 : (Ο„ X xs.length).isSome = true c2 : Β¬xs.length = ((Ο„ X xs.length).get β‹―).1.length ⊒ I.pred_var_ X (List.map V xs) ↔ Holds D I V E (pred_var_ X xs) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
[90, 1]
[226, 15]
case _ c1 => simp only [Holds]
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True c1 : Β¬(Ο„ X xs.length).isSome = true ⊒ I.pred_var_ X (List.map V xs) ↔ Holds D I V E (pred_var_ X xs)
no goals
Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True c1 : Β¬(Ο„ X xs.length).isSome = true ⊒ I.pred_var_ X (List.map V xs) ↔ Holds D I V E (pred_var_ X xs) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
[90, 1]
[226, 15]
let opt := Ο„ X xs.length
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True c1 : (Ο„ X xs.length).isSome = true c2 : xs.length = ((Ο„ X xs.length).get β‹―).1.length ⊒ Holds D I (Function.updateListITE V' ((Ο„ X xs.length).get β‹―).1 (List.map V xs)) E ((Ο„ X xs.length).get β‹―).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο„ X xs.length).get β‹―).1 xs) c ((Ο„ X xs.length).get β‹―).2)
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True c1 : (Ο„ X xs.length).isSome = true c2 : xs.length = ((Ο„ X xs.length).get β‹―).1.length opt : Option (List VarName Γ— Formula) := Ο„ X xs.length ⊒ Holds D I (Function.updateListITE V' ((Ο„ X xs.length).get β‹―).1 (List.map V xs)) E ((Ο„ X xs.length).get β‹―).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο„ X xs.length).get β‹―).1 xs) c ((Ο„ X xs.length).get β‹―).2)
Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True c1 : (Ο„ X xs.length).isSome = true c2 : xs.length = ((Ο„ X xs.length).get β‹―).1.length ⊒ Holds D I (Function.updateListITE V' ((Ο„ X xs.length).get β‹―).1 (List.map V xs)) E ((Ο„ X xs.length).get β‹―).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο„ X xs.length).get β‹―).1 xs) c ((Ο„ X xs.length).get β‹―).2) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
[90, 1]
[226, 15]
let val := Option.get opt c1
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True c1 : (Ο„ X xs.length).isSome = true c2 : xs.length = ((Ο„ X xs.length).get β‹―).1.length opt : Option (List VarName Γ— Formula) := Ο„ X xs.length ⊒ Holds D I (Function.updateListITE V' ((Ο„ X xs.length).get β‹―).1 (List.map V xs)) E ((Ο„ X xs.length).get β‹―).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο„ X xs.length).get β‹―).1 xs) c ((Ο„ X xs.length).get β‹―).2)
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True c1 : (Ο„ X xs.length).isSome = true c2 : xs.length = ((Ο„ X xs.length).get β‹―).1.length opt : Option (List VarName Γ— Formula) := Ο„ X xs.length val : List VarName Γ— Formula := opt.get c1 ⊒ Holds D I (Function.updateListITE V' ((Ο„ X xs.length).get β‹―).1 (List.map V xs)) E ((Ο„ X xs.length).get β‹―).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο„ X xs.length).get β‹―).1 xs) c ((Ο„ X xs.length).get β‹―).2)
Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True c1 : (Ο„ X xs.length).isSome = true c2 : xs.length = ((Ο„ X xs.length).get β‹―).1.length opt : Option (List VarName Γ— Formula) := Ο„ X xs.length ⊒ Holds D I (Function.updateListITE V' ((Ο„ X xs.length).get β‹―).1 (List.map V xs)) E ((Ο„ X xs.length).get β‹―).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο„ X xs.length).get β‹―).1 xs) c ((Ο„ X xs.length).get β‹―).2) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
[90, 1]
[226, 15]
let zs := val.fst
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True c1 : (Ο„ X xs.length).isSome = true c2 : xs.length = ((Ο„ X xs.length).get β‹―).1.length opt : Option (List VarName Γ— Formula) := Ο„ X xs.length val : List VarName Γ— Formula := opt.get c1 ⊒ Holds D I (Function.updateListITE V' ((Ο„ X xs.length).get β‹―).1 (List.map V xs)) E ((Ο„ X xs.length).get β‹―).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο„ X xs.length).get β‹―).1 xs) c ((Ο„ X xs.length).get β‹―).2)
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True c1 : (Ο„ X xs.length).isSome = true c2 : xs.length = ((Ο„ X xs.length).get β‹―).1.length opt : Option (List VarName Γ— Formula) := Ο„ X xs.length val : List VarName Γ— Formula := opt.get c1 zs : List VarName := val.1 ⊒ Holds D I (Function.updateListITE V' ((Ο„ X xs.length).get β‹―).1 (List.map V xs)) E ((Ο„ X xs.length).get β‹―).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο„ X xs.length).get β‹―).1 xs) c ((Ο„ X xs.length).get β‹―).2)
Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True c1 : (Ο„ X xs.length).isSome = true c2 : xs.length = ((Ο„ X xs.length).get β‹―).1.length opt : Option (List VarName Γ— Formula) := Ο„ X xs.length val : List VarName Γ— Formula := opt.get c1 ⊒ Holds D I (Function.updateListITE V' ((Ο„ X xs.length).get β‹―).1 (List.map V xs)) E ((Ο„ X xs.length).get β‹―).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο„ X xs.length).get β‹―).1 xs) c ((Ο„ X xs.length).get β‹―).2) TACTIC:
https://github.com/pthomas505/FOL.git
097a4abea51b641d144539b9a0f7516f3b9d818c
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
[90, 1]
[226, 15]
let H := val.snd
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True c1 : (Ο„ X xs.length).isSome = true c2 : xs.length = ((Ο„ X xs.length).get β‹―).1.length opt : Option (List VarName Γ— Formula) := Ο„ X xs.length val : List VarName Γ— Formula := opt.get c1 zs : List VarName := val.1 ⊒ Holds D I (Function.updateListITE V' ((Ο„ X xs.length).get β‹―).1 (List.map V xs)) E ((Ο„ X xs.length).get β‹―).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο„ X xs.length).get β‹―).1 xs) c ((Ο„ X xs.length).get β‹―).2)
D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True c1 : (Ο„ X xs.length).isSome = true c2 : xs.length = ((Ο„ X xs.length).get β‹―).1.length opt : Option (List VarName Γ— Formula) := Ο„ X xs.length val : List VarName Γ— Formula := opt.get c1 zs : List VarName := val.1 H : Formula := val.2 ⊒ Holds D I (Function.updateListITE V' ((Ο„ X xs.length).get β‹―).1 (List.map V xs)) E ((Ο„ X xs.length).get β‹―).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο„ X xs.length).get β‹―).1 xs) c ((Ο„ X xs.length).get β‹―).2)
Please generate a tactic in lean4 to solve the state. STATE: D : Type I : Interpretation D V' : VarAssignment D E : Env c : Char Ο„ : PredName β†’ β„• β†’ Option (List VarName Γ— Formula) X : PredName xs : List VarName V : VarAssignment D binders : Finset VarName h2 : βˆ€ x βˆ‰ binders, V' x = V x h1 : if h : (Ο„ X xs.length).isSome = true then xs.length = ((Ο„ X xs.length).get β‹―).1.length β†’ binders ∩ (((Ο„ X xs.length).get β‹―).2.freeVarSet \ ((Ο„ X xs.length).get β‹―).1.toFinset) = βˆ… else True c1 : (Ο„ X xs.length).isSome = true c2 : xs.length = ((Ο„ X xs.length).get β‹―).1.length opt : Option (List VarName Γ— Formula) := Ο„ X xs.length val : List VarName Γ— Formula := opt.get c1 zs : List VarName := val.1 ⊒ Holds D I (Function.updateListITE V' ((Ο„ X xs.length).get β‹―).1 (List.map V xs)) E ((Ο„ X xs.length).get β‹―).2 ↔ Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο„ X xs.length).get β‹―).1 xs) c ((Ο„ X xs.length).get β‹―).2) TACTIC: