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/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
congr! 1
|
Δ : List Formula
F : Formula
X : PredName
xs ys : List VarName
ih_1 : xs.length = ys.length
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs ys))
⊢ I.pred_var_ X (List.map V xs) ↔ I.pred_var_ X (List.map V ys)
|
case a.h.e'_4
Δ : List Formula
F : Formula
X : PredName
xs ys : List VarName
ih_1 : xs.length = ys.length
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs ys))
⊢ List.map V xs = List.map V ys
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
X : PredName
xs ys : List VarName
ih_1 : xs.length = ys.length
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs ys))
⊢ I.pred_var_ X (List.map V xs) ↔ I.pred_var_ X (List.map V ys)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
induction xs generalizing ys
|
case a.h.e'_4
Δ : List Formula
F : Formula
X : PredName
xs ys : List VarName
ih_1 : xs.length = ys.length
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs ys))
⊢ List.map V xs = List.map V ys
|
case a.h.e'_4.nil
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
ys : List VarName
ih_1 : [].length = ys.length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ [] ys))
⊢ List.map V [] = List.map V ys
case a.h.e'_4.cons
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
head✝ : VarName
tail✝ : List VarName
tail_ih✝ :
∀ (ys : List VarName),
tail✝.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ tail✝ ys)) → List.map V tail✝ = List.map V ys
ys : List VarName
ih_1 : (head✝ :: tail✝).length = ys.length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ (head✝ :: tail✝) ys))
⊢ List.map V (head✝ :: tail✝) = List.map V ys
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.e'_4
Δ : List Formula
F : Formula
X : PredName
xs ys : List VarName
ih_1 : xs.length = ys.length
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs ys))
⊢ List.map V xs = List.map V ys
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
case _ =>
cases ys
case _ =>
simp only [Holds]
case cons ys_hd ys_tl =>
simp at ih_1
|
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
ys : List VarName
ih_1 : [].length = ys.length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ [] ys))
⊢ List.map V [] = List.map V ys
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
ys : List VarName
ih_1 : [].length = ys.length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ [] ys))
⊢ List.map V [] = List.map V ys
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
cases ys
|
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
ys : List VarName
ih_1 : [].length = ys.length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ [] ys))
⊢ List.map V [] = List.map V ys
|
case nil
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
ih_1 : [].length = [].length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ [] []))
⊢ List.map V [] = List.map V []
case cons
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
head✝ : VarName
tail✝ : List VarName
ih_1 : [].length = (head✝ :: tail✝).length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ [] (head✝ :: tail✝)))
⊢ List.map V [] = List.map V (head✝ :: tail✝)
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
ys : List VarName
ih_1 : [].length = ys.length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ [] ys))
⊢ List.map V [] = List.map V ys
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
case _ =>
simp only [Holds]
|
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
ih_1 : [].length = [].length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ [] []))
⊢ List.map V [] = List.map V []
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
ih_1 : [].length = [].length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ [] []))
⊢ List.map V [] = List.map V []
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
case cons ys_hd ys_tl =>
simp at ih_1
|
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
ys_hd : VarName
ys_tl : List VarName
ih_1 : [].length = (ys_hd :: ys_tl).length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ [] (ys_hd :: ys_tl)))
⊢ List.map V [] = List.map V (ys_hd :: ys_tl)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
ys_hd : VarName
ys_tl : List VarName
ih_1 : [].length = (ys_hd :: ys_tl).length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ [] (ys_hd :: ys_tl)))
⊢ List.map V [] = List.map V (ys_hd :: ys_tl)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
simp only [Holds]
|
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
ih_1 : [].length = [].length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ [] []))
⊢ List.map V [] = List.map V []
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
ih_1 : [].length = [].length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ [] []))
⊢ List.map V [] = List.map V []
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
simp at ih_1
|
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
ys_hd : VarName
ys_tl : List VarName
ih_1 : [].length = (ys_hd :: ys_tl).length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ [] (ys_hd :: ys_tl)))
⊢ List.map V [] = List.map V (ys_hd :: ys_tl)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
ys_hd : VarName
ys_tl : List VarName
ih_1 : [].length = (ys_hd :: ys_tl).length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ [] (ys_hd :: ys_tl)))
⊢ List.map V [] = List.map V (ys_hd :: ys_tl)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
cases ys
|
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ys : List VarName
ih_1 : (xs_hd :: xs_tl).length = ys.length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ (xs_hd :: xs_tl) ys))
⊢ List.map V (xs_hd :: xs_tl) = List.map V ys
|
case nil
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ih_1 : (xs_hd :: xs_tl).length = [].length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ (xs_hd :: xs_tl) []))
⊢ List.map V (xs_hd :: xs_tl) = List.map V []
case cons
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
head✝ : VarName
tail✝ : List VarName
ih_1 : (xs_hd :: xs_tl).length = (head✝ :: tail✝).length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ (xs_hd :: xs_tl) (head✝ :: tail✝)))
⊢ List.map V (xs_hd :: xs_tl) = List.map V (head✝ :: tail✝)
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ys : List VarName
ih_1 : (xs_hd :: xs_tl).length = ys.length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ (xs_hd :: xs_tl) ys))
⊢ List.map V (xs_hd :: xs_tl) = List.map V ys
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
case nil =>
simp at ih_1
|
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ih_1 : (xs_hd :: xs_tl).length = [].length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ (xs_hd :: xs_tl) []))
⊢ List.map V (xs_hd :: xs_tl) = List.map V []
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ih_1 : (xs_hd :: xs_tl).length = [].length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ (xs_hd :: xs_tl) []))
⊢ List.map V (xs_hd :: xs_tl) = List.map V []
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
simp at ih_1
|
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ih_1 : (xs_hd :: xs_tl).length = [].length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ (xs_hd :: xs_tl) []))
⊢ List.map V (xs_hd :: xs_tl) = List.map V []
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ih_1 : (xs_hd :: xs_tl).length = [].length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ (xs_hd :: xs_tl) []))
⊢ List.map V (xs_hd :: xs_tl) = List.map V []
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
simp at ih_1
|
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ys_hd : VarName
ys_tl : List VarName
ih_1 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ (xs_hd :: xs_tl) (ys_hd :: ys_tl)))
⊢ List.map V (xs_hd :: xs_tl) = List.map V (ys_hd :: ys_tl)
|
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ys_hd : VarName
ys_tl : List VarName
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ (xs_hd :: xs_tl) (ys_hd :: ys_tl)))
ih_1 : xs_tl.length = ys_tl.length
⊢ List.map V (xs_hd :: xs_tl) = List.map V (ys_hd :: ys_tl)
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ys_hd : VarName
ys_tl : List VarName
ih_1 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ (xs_hd :: xs_tl) (ys_hd :: ys_tl)))
⊢ List.map V (xs_hd :: xs_tl) = List.map V (ys_hd :: ys_tl)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
simp at a1
|
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ys_hd : VarName
ys_tl : List VarName
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ (xs_hd :: xs_tl) (ys_hd :: ys_tl)))
ih_1 : xs_tl.length = ys_tl.length
⊢ List.map V (xs_hd :: xs_tl) = List.map V (ys_hd :: ys_tl)
|
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ys_hd : VarName
ys_tl : List VarName
a1 : Holds D I V E ((eq_ xs_hd ys_hd).and_ (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys_tl)))
ih_1 : xs_tl.length = ys_tl.length
⊢ List.map V (xs_hd :: xs_tl) = List.map V (ys_hd :: ys_tl)
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ys_hd : VarName
ys_tl : List VarName
a1 : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ (xs_hd :: xs_tl) (ys_hd :: ys_tl)))
ih_1 : xs_tl.length = ys_tl.length
⊢ List.map V (xs_hd :: xs_tl) = List.map V (ys_hd :: ys_tl)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
simp only [Holds] at a1
|
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ys_hd : VarName
ys_tl : List VarName
a1 : Holds D I V E ((eq_ xs_hd ys_hd).and_ (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys_tl)))
ih_1 : xs_tl.length = ys_tl.length
⊢ List.map V (xs_hd :: xs_tl) = List.map V (ys_hd :: ys_tl)
|
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ys_hd : VarName
ys_tl : List VarName
ih_1 : xs_tl.length = ys_tl.length
a1 : V xs_hd = V ys_hd ∧ Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys_tl))
⊢ List.map V (xs_hd :: xs_tl) = List.map V (ys_hd :: ys_tl)
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ys_hd : VarName
ys_tl : List VarName
a1 : Holds D I V E ((eq_ xs_hd ys_hd).and_ (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys_tl)))
ih_1 : xs_tl.length = ys_tl.length
⊢ List.map V (xs_hd :: xs_tl) = List.map V (ys_hd :: ys_tl)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
cases a1
|
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ys_hd : VarName
ys_tl : List VarName
ih_1 : xs_tl.length = ys_tl.length
a1 : V xs_hd = V ys_hd ∧ Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys_tl))
⊢ List.map V (xs_hd :: xs_tl) = List.map V (ys_hd :: ys_tl)
|
case intro
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ys_hd : VarName
ys_tl : List VarName
ih_1 : xs_tl.length = ys_tl.length
left✝ : V xs_hd = V ys_hd
right✝ : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys_tl))
⊢ List.map V (xs_hd :: xs_tl) = List.map V (ys_hd :: ys_tl)
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ys_hd : VarName
ys_tl : List VarName
ih_1 : xs_tl.length = ys_tl.length
a1 : V xs_hd = V ys_hd ∧ Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys_tl))
⊢ List.map V (xs_hd :: xs_tl) = List.map V (ys_hd :: ys_tl)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
simp
|
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ys_hd : VarName
ys_tl : List VarName
ih_1 : xs_tl.length = ys_tl.length
a1_left : V xs_hd = V ys_hd
a1_right : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys_tl))
⊢ List.map V (xs_hd :: xs_tl) = List.map V (ys_hd :: ys_tl)
|
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ys_hd : VarName
ys_tl : List VarName
ih_1 : xs_tl.length = ys_tl.length
a1_left : V xs_hd = V ys_hd
a1_right : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys_tl))
⊢ V xs_hd = V ys_hd ∧ List.map V xs_tl = List.map V ys_tl
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ys_hd : VarName
ys_tl : List VarName
ih_1 : xs_tl.length = ys_tl.length
a1_left : V xs_hd = V ys_hd
a1_right : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys_tl))
⊢ List.map V (xs_hd :: xs_tl) = List.map V (ys_hd :: ys_tl)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
constructor
|
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ys_hd : VarName
ys_tl : List VarName
ih_1 : xs_tl.length = ys_tl.length
a1_left : V xs_hd = V ys_hd
a1_right : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys_tl))
⊢ V xs_hd = V ys_hd ∧ List.map V xs_tl = List.map V ys_tl
|
case left
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ys_hd : VarName
ys_tl : List VarName
ih_1 : xs_tl.length = ys_tl.length
a1_left : V xs_hd = V ys_hd
a1_right : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys_tl))
⊢ V xs_hd = V ys_hd
case right
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ys_hd : VarName
ys_tl : List VarName
ih_1 : xs_tl.length = ys_tl.length
a1_left : V xs_hd = V ys_hd
a1_right : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys_tl))
⊢ List.map V xs_tl = List.map V ys_tl
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ys_hd : VarName
ys_tl : List VarName
ih_1 : xs_tl.length = ys_tl.length
a1_left : V xs_hd = V ys_hd
a1_right : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys_tl))
⊢ V xs_hd = V ys_hd ∧ List.map V xs_tl = List.map V ys_tl
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
exact a1_left
|
case left
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ys_hd : VarName
ys_tl : List VarName
ih_1 : xs_tl.length = ys_tl.length
a1_left : V xs_hd = V ys_hd
a1_right : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys_tl))
⊢ V xs_hd = V ys_hd
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case left
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ys_hd : VarName
ys_tl : List VarName
ih_1 : xs_tl.length = ys_tl.length
a1_left : V xs_hd = V ys_hd
a1_right : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys_tl))
⊢ V xs_hd = V ys_hd
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
apply xs_ih ys_tl ih_1 a1_right
|
case right
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ys_hd : VarName
ys_tl : List VarName
ih_1 : xs_tl.length = ys_tl.length
a1_left : V xs_hd = V ys_hd
a1_right : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys_tl))
⊢ List.map V xs_tl = List.map V ys_tl
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case right
Δ : List Formula
F : Formula
X : PredName
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
xs_hd : VarName
xs_tl : List VarName
xs_ih :
∀ (ys : List VarName),
xs_tl.length = ys.length →
Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys)) → List.map V xs_tl = List.map V ys
ys_hd : VarName
ys_tl : List VarName
ih_1 : xs_tl.length = ys_tl.length
a1_left : V xs_hd = V ys_hd
a1_right : Holds D I V E (List.foldr and_ true_ (List.zipWith eq_ xs_tl ys_tl))
⊢ List.map V xs_tl = List.map V ys_tl
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
intro D I V E _
|
Δ : List Formula
F : Formula
⊢ ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env),
(∀ H ∈ [], Holds D I V E H) → Holds D I V E (false_.iff_ true_.not_)
|
Δ : List Formula
F : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ Holds D I V E (false_.iff_ true_.not_)
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
⊢ ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env),
(∀ H ∈ [], Holds D I V E H) → Holds D I V E (false_.iff_ true_.not_)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
simp only [Holds]
|
Δ : List Formula
F : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ Holds D I V E (false_.iff_ true_.not_)
|
Δ : List Formula
F : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ False ↔ ¬True
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ Holds D I V E (false_.iff_ true_.not_)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
tauto
|
Δ : List Formula
F : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ False ↔ ¬True
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ False ↔ ¬True
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
intro D I V E _
|
Δ : List Formula
F phi psi : Formula
⊢ ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env),
(∀ H ∈ [], Holds D I V E H) → Holds D I V E ((phi.and_ psi).iff_ (phi.imp_ psi.not_).not_)
|
Δ : List Formula
F phi psi : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ Holds D I V E ((phi.and_ psi).iff_ (phi.imp_ psi.not_).not_)
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F phi psi : Formula
⊢ ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env),
(∀ H ∈ [], Holds D I V E H) → Holds D I V E ((phi.and_ psi).iff_ (phi.imp_ psi.not_).not_)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
simp only [Holds]
|
Δ : List Formula
F phi psi : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ Holds D I V E ((phi.and_ psi).iff_ (phi.imp_ psi.not_).not_)
|
Δ : List Formula
F phi psi : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ Holds D I V E phi ∧ Holds D I V E psi ↔ ¬(Holds D I V E phi → ¬Holds D I V E psi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F phi psi : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ Holds D I V E ((phi.and_ psi).iff_ (phi.imp_ psi.not_).not_)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
tauto
|
Δ : List Formula
F phi psi : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ Holds D I V E phi ∧ Holds D I V E psi ↔ ¬(Holds D I V E phi → ¬Holds D I V E psi)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F phi psi : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ Holds D I V E phi ∧ Holds D I V E psi ↔ ¬(Holds D I V E phi → ¬Holds D I V E psi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
intro D I V E _
|
Δ : List Formula
F phi psi : Formula
⊢ ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env),
(∀ H ∈ [], Holds D I V E H) → Holds D I V E ((phi.or_ psi).iff_ (phi.not_.imp_ psi))
|
Δ : List Formula
F phi psi : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ Holds D I V E ((phi.or_ psi).iff_ (phi.not_.imp_ psi))
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F phi psi : Formula
⊢ ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env),
(∀ H ∈ [], Holds D I V E H) → Holds D I V E ((phi.or_ psi).iff_ (phi.not_.imp_ psi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
simp only [Holds]
|
Δ : List Formula
F phi psi : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ Holds D I V E ((phi.or_ psi).iff_ (phi.not_.imp_ psi))
|
Δ : List Formula
F phi psi : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ Holds D I V E phi ∨ Holds D I V E psi ↔ ¬Holds D I V E phi → Holds D I V E psi
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F phi psi : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ Holds D I V E ((phi.or_ psi).iff_ (phi.not_.imp_ psi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
tauto
|
Δ : List Formula
F phi psi : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ Holds D I V E phi ∨ Holds D I V E psi ↔ ¬Holds D I V E phi → Holds D I V E psi
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F phi psi : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ Holds D I V E phi ∨ Holds D I V E psi ↔ ¬Holds D I V E phi → Holds D I V E psi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
intro D I V E _
|
Δ : List Formula
F phi psi : Formula
⊢ ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env),
(∀ H ∈ [], Holds D I V E H) →
Holds D I V E
(((phi.iff_ psi).imp_ ((phi.imp_ psi).imp_ (psi.imp_ phi).not_).not_).imp_
(((phi.imp_ psi).imp_ (psi.imp_ phi).not_).not_.imp_ (phi.iff_ psi)).not_).not_
|
Δ : List Formula
F phi psi : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ Holds D I V E
(((phi.iff_ psi).imp_ ((phi.imp_ psi).imp_ (psi.imp_ phi).not_).not_).imp_
(((phi.imp_ psi).imp_ (psi.imp_ phi).not_).not_.imp_ (phi.iff_ psi)).not_).not_
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F phi psi : Formula
⊢ ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env),
(∀ H ∈ [], Holds D I V E H) →
Holds D I V E
(((phi.iff_ psi).imp_ ((phi.imp_ psi).imp_ (psi.imp_ phi).not_).not_).imp_
(((phi.imp_ psi).imp_ (psi.imp_ phi).not_).not_.imp_ (phi.iff_ psi)).not_).not_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
simp only [Holds]
|
Δ : List Formula
F phi psi : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ Holds D I V E
(((phi.iff_ psi).imp_ ((phi.imp_ psi).imp_ (psi.imp_ phi).not_).not_).imp_
(((phi.imp_ psi).imp_ (psi.imp_ phi).not_).not_.imp_ (phi.iff_ psi)).not_).not_
|
Δ : List Formula
F phi psi : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ ¬(((Holds D I V E phi ↔ Holds D I V E psi) →
¬((Holds D I V E phi → Holds D I V E psi) → ¬(Holds D I V E psi → Holds D I V E phi))) →
¬(¬((Holds D I V E phi → Holds D I V E psi) → ¬(Holds D I V E psi → Holds D I V E phi)) →
(Holds D I V E phi ↔ Holds D I V E psi)))
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F phi psi : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ Holds D I V E
(((phi.iff_ psi).imp_ ((phi.imp_ psi).imp_ (psi.imp_ phi).not_).not_).imp_
(((phi.imp_ psi).imp_ (psi.imp_ phi).not_).not_.imp_ (phi.iff_ psi)).not_).not_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
tauto
|
Δ : List Formula
F phi psi : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ ¬(((Holds D I V E phi ↔ Holds D I V E psi) →
¬((Holds D I V E phi → Holds D I V E psi) → ¬(Holds D I V E psi → Holds D I V E phi))) →
¬(¬((Holds D I V E phi → Holds D I V E psi) → ¬(Holds D I V E psi → Holds D I V E phi)) →
(Holds D I V E phi ↔ Holds D I V E psi)))
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F phi psi : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ ¬(((Holds D I V E phi ↔ Holds D I V E psi) →
¬((Holds D I V E phi → Holds D I V E psi) → ¬(Holds D I V E psi → Holds D I V E phi))) →
¬(¬((Holds D I V E phi → Holds D I V E psi) → ¬(Holds D I V E psi → Holds D I V E phi)) →
(Holds D I V E phi ↔ Holds D I V E psi)))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
intro D I V E _
|
Δ : List Formula
F : Formula
v : VarName
phi : Formula
⊢ ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env),
(∀ H ∈ [], Holds D I V E H) → Holds D I V E ((exists_ v phi).iff_ (forall_ v phi.not_).not_)
|
Δ : List Formula
F : Formula
v : VarName
phi : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ Holds D I V E ((exists_ v phi).iff_ (forall_ v phi.not_).not_)
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
v : VarName
phi : Formula
⊢ ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env),
(∀ H ∈ [], Holds D I V E H) → Holds D I V E ((exists_ v phi).iff_ (forall_ v phi.not_).not_)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
simp only [Holds]
|
Δ : List Formula
F : Formula
v : VarName
phi : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ Holds D I V E ((exists_ v phi).iff_ (forall_ v phi.not_).not_)
|
Δ : List Formula
F : Formula
v : VarName
phi : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ (∃ d, Holds D I (Function.updateITE V v d) E phi) ↔ ¬∀ (d : D), ¬Holds D I (Function.updateITE V v d) E phi
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
v : VarName
phi : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ Holds D I V E ((exists_ v phi).iff_ (forall_ v phi.not_).not_)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
simp
|
Δ : List Formula
F : Formula
v : VarName
phi : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ (∃ d, Holds D I (Function.updateITE V v d) E phi) ↔ ¬∀ (d : D), ¬Holds D I (Function.updateITE V v d) E phi
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
v : VarName
phi : Formula
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a✝ : ∀ H ∈ [], Holds D I V E H
⊢ (∃ d, Holds D I (Function.updateITE V v d) E phi) ↔ ¬∀ (d : D), ¬Holds D I (Function.updateITE V v d) E phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
intro D I V E a1
|
Δ : List Formula
F : Formula
Δ' : List Formula
phi : Formula
τ : PredName → ℕ → Option (List VarName × Formula)
a✝ : IsDeduct Δ' phi
ih_2 :
∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), (∀ H ∈ Δ', Holds D I V E H) → Holds D I V E phi
⊢ ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env),
(∀ H ∈ List.map (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ) Δ', Holds D I V E H) →
Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ phi)
|
Δ : List Formula
F : Formula
Δ' : List Formula
phi : Formula
τ : PredName → ℕ → Option (List VarName × Formula)
a✝ : IsDeduct Δ' phi
ih_2 :
∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), (∀ H ∈ Δ', Holds D I V E H) → Holds D I V E phi
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a1 : ∀ H ∈ List.map (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ) Δ', Holds D I V E H
⊢ Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
Δ' : List Formula
phi : Formula
τ : PredName → ℕ → Option (List VarName × Formula)
a✝ : IsDeduct Δ' phi
ih_2 :
∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), (∀ H ∈ Δ', Holds D I V E H) → Holds D I V E phi
⊢ ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env),
(∀ H ∈ List.map (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ) Δ', Holds D I V E H) →
Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
simp at a1
|
Δ : List Formula
F : Formula
Δ' : List Formula
phi : Formula
τ : PredName → ℕ → Option (List VarName × Formula)
a✝ : IsDeduct Δ' phi
ih_2 :
∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), (∀ H ∈ Δ', Holds D I V E H) → Holds D I V E phi
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a1 : ∀ H ∈ List.map (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ) Δ', Holds D I V E H
⊢ Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ phi)
|
Δ : List Formula
F : Formula
Δ' : List Formula
phi : Formula
τ : PredName → ℕ → Option (List VarName × Formula)
a✝ : IsDeduct Δ' phi
ih_2 :
∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), (∀ H ∈ Δ', Holds D I V E H) → Holds D I V E phi
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a1 : ∀ a ∈ Δ', Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ a)
⊢ Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
Δ' : List Formula
phi : Formula
τ : PredName → ℕ → Option (List VarName × Formula)
a✝ : IsDeduct Δ' phi
ih_2 :
∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), (∀ H ∈ Δ', Holds D I V E H) → Holds D I V E phi
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a1 : ∀ H ∈ List.map (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ) Δ', Holds D I V E H
⊢ Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
obtain s1 := Sub.Pred.All.Rec.Option.Fresh.substitution_theorem D I V E freshChar τ
|
Δ : List Formula
F : Formula
Δ' : List Formula
phi : Formula
τ : PredName → ℕ → Option (List VarName × Formula)
a✝ : IsDeduct Δ' phi
ih_2 :
∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), (∀ H ∈ Δ', Holds D I V E H) → Holds D I V E phi
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a1 : ∀ a ∈ Δ', Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ a)
⊢ Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ phi)
|
Δ : List Formula
F : Formula
Δ' : List Formula
phi : Formula
τ : PredName → ℕ → Option (List VarName × Formula)
a✝ : IsDeduct Δ' phi
ih_2 :
∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), (∀ H ∈ Δ', Holds D I V E H) → Holds D I V E phi
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a1 : ∀ a ∈ Δ', Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ a)
s1 :
∀ (F : Formula),
Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E F ↔
Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ F)
⊢ Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
Δ' : List Formula
phi : Formula
τ : PredName → ℕ → Option (List VarName × Formula)
a✝ : IsDeduct Δ' phi
ih_2 :
∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), (∀ H ∈ Δ', Holds D I V E H) → Holds D I V E phi
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a1 : ∀ a ∈ Δ', Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ a)
⊢ Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
simp only [← s1] at a1
|
Δ : List Formula
F : Formula
Δ' : List Formula
phi : Formula
τ : PredName → ℕ → Option (List VarName × Formula)
a✝ : IsDeduct Δ' phi
ih_2 :
∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), (∀ H ∈ Δ', Holds D I V E H) → Holds D I V E phi
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a1 : ∀ a ∈ Δ', Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ a)
s1 :
∀ (F : Formula),
Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E F ↔
Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ F)
⊢ Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ phi)
|
Δ : List Formula
F : Formula
Δ' : List Formula
phi : Formula
τ : PredName → ℕ → Option (List VarName × Formula)
a✝ : IsDeduct Δ' phi
ih_2 :
∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), (∀ H ∈ Δ', Holds D I V E H) → Holds D I V E phi
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
s1 :
∀ (F : Formula),
Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E F ↔
Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ F)
a1 : ∀ a ∈ Δ', Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E a
⊢ Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
Δ' : List Formula
phi : Formula
τ : PredName → ℕ → Option (List VarName × Formula)
a✝ : IsDeduct Δ' phi
ih_2 :
∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), (∀ H ∈ Δ', Holds D I V E H) → Holds D I V E phi
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
a1 : ∀ a ∈ Δ', Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ a)
s1 :
∀ (F : Formula),
Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E F ↔
Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ F)
⊢ Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
simp only [← s1]
|
Δ : List Formula
F : Formula
Δ' : List Formula
phi : Formula
τ : PredName → ℕ → Option (List VarName × Formula)
a✝ : IsDeduct Δ' phi
ih_2 :
∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), (∀ H ∈ Δ', Holds D I V E H) → Holds D I V E phi
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
s1 :
∀ (F : Formula),
Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E F ↔
Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ F)
a1 : ∀ a ∈ Δ', Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E a
⊢ Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ phi)
|
Δ : List Formula
F : Formula
Δ' : List Formula
phi : Formula
τ : PredName → ℕ → Option (List VarName × Formula)
a✝ : IsDeduct Δ' phi
ih_2 :
∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), (∀ H ∈ Δ', Holds D I V E H) → Holds D I V E phi
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
s1 :
∀ (F : Formula),
Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E F ↔
Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ F)
a1 : ∀ a ∈ Δ', Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E a
⊢ Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E phi
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
Δ' : List Formula
phi : Formula
τ : PredName → ℕ → Option (List VarName × Formula)
a✝ : IsDeduct Δ' phi
ih_2 :
∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), (∀ H ∈ Δ', Holds D I V E H) → Holds D I V E phi
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
s1 :
∀ (F : Formula),
Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E F ↔
Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ F)
a1 : ∀ a ∈ Δ', Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E a
⊢ Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
apply ih_2
|
Δ : List Formula
F : Formula
Δ' : List Formula
phi : Formula
τ : PredName → ℕ → Option (List VarName × Formula)
a✝ : IsDeduct Δ' phi
ih_2 :
∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), (∀ H ∈ Δ', Holds D I V E H) → Holds D I V E phi
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
s1 :
∀ (F : Formula),
Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E F ↔
Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ F)
a1 : ∀ a ∈ Δ', Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E a
⊢ Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E phi
|
case a
Δ : List Formula
F : Formula
Δ' : List Formula
phi : Formula
τ : PredName → ℕ → Option (List VarName × Formula)
a✝ : IsDeduct Δ' phi
ih_2 :
∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), (∀ H ∈ Δ', Holds D I V E H) → Holds D I V E phi
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
s1 :
∀ (F : Formula),
Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E F ↔
Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ F)
a1 : ∀ a ∈ Δ', Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E a
⊢ ∀ H ∈ Δ', Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E H
|
Please generate a tactic in lean4 to solve the state.
STATE:
Δ : List Formula
F : Formula
Δ' : List Formula
phi : Formula
τ : PredName → ℕ → Option (List VarName × Formula)
a✝ : IsDeduct Δ' phi
ih_2 :
∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), (∀ H ∈ Δ', Holds D I V E H) → Holds D I V E phi
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
s1 :
∀ (F : Formula),
Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E F ↔
Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ F)
a1 : ∀ a ∈ Δ', Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E a
⊢ Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.soundness
|
[793, 1]
|
[979, 13]
|
exact a1
|
case a
Δ : List Formula
F : Formula
Δ' : List Formula
phi : Formula
τ : PredName → ℕ → Option (List VarName × Formula)
a✝ : IsDeduct Δ' phi
ih_2 :
∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), (∀ H ∈ Δ', Holds D I V E H) → Holds D I V E phi
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
s1 :
∀ (F : Formula),
Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E F ↔
Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ F)
a1 : ∀ a ∈ Δ', Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E a
⊢ ∀ H ∈ Δ', Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E H
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a
Δ : List Formula
F : Formula
Δ' : List Formula
phi : Formula
τ : PredName → ℕ → Option (List VarName × Formula)
a✝ : IsDeduct Δ' phi
ih_2 :
∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), (∀ H ∈ Δ', Holds D I V E H) → Holds D I V E phi
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
s1 :
∀ (F : Formula),
Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E F ↔
Holds D I V E (Sub.Pred.All.Rec.Option.Fresh.sub freshChar τ F)
a1 : ∀ a ∈ Δ', Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E a
⊢ ∀ H ∈ Δ', Holds D (Sub.Pred.All.Rec.Option.Fresh.I' D I V E τ) V E H
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.not_IsDeduct_false
|
[982, 1]
|
[988, 26]
|
intro contra
|
⊢ ¬IsDeduct [] false_
|
contra : IsDeduct [] false_
⊢ False
|
Please generate a tactic in lean4 to solve the state.
STATE:
⊢ ¬IsDeduct [] false_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.not_IsDeduct_false
|
[982, 1]
|
[988, 26]
|
obtain s1 := soundness [] false_ contra Unit default default default
|
contra : IsDeduct [] false_
⊢ False
|
contra : IsDeduct [] false_
s1 : (∀ H ∈ [], Holds Unit default default default H) → Holds Unit default default default false_
⊢ False
|
Please generate a tactic in lean4 to solve the state.
STATE:
contra : IsDeduct [] false_
⊢ False
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.not_IsDeduct_false
|
[982, 1]
|
[988, 26]
|
simp at s1
|
contra : IsDeduct [] false_
s1 : (∀ H ∈ [], Holds Unit default default default H) → Holds Unit default default default false_
⊢ False
|
contra : IsDeduct [] false_
s1 : Holds Unit default default default false_
⊢ False
|
Please generate a tactic in lean4 to solve the state.
STATE:
contra : IsDeduct [] false_
s1 : (∀ H ∈ [], Holds Unit default default default H) → Holds Unit default default default false_
⊢ False
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/Backend.lean
|
FOL.NV.Program.Backend.not_IsDeduct_false
|
[982, 1]
|
[988, 26]
|
simp only [Holds] at s1
|
contra : IsDeduct [] false_
s1 : Holds Unit default default default false_
⊢ False
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
contra : IsDeduct [] false_
s1 : Holds Unit default default default false_
⊢ False
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_char_EpsilonNFA_toAbstract
|
[50, 1]
|
[63, 9]
|
simp only [match_char_EpsilonNFA]
|
α : Type
inst✝ : DecidableEq α
c : α
⊢ (match_char_EpsilonNFA c).toAbstract = match_char_AbstractEpsilonNFA c
|
α : Type
inst✝ : DecidableEq α
c : α
⊢ { symbol_arrow_list := [{ start_state := 0, symbol := c, stop_state_list := [1] }], epsilon_arrow_list := [],
starting_state_list := [0], accepting_state_list := [1] }.toAbstract =
match_char_AbstractEpsilonNFA c
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : DecidableEq α
c : α
⊢ (match_char_EpsilonNFA c).toAbstract = match_char_AbstractEpsilonNFA c
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_char_EpsilonNFA_toAbstract
|
[50, 1]
|
[63, 9]
|
simp only [EpsilonNFA.toAbstract]
|
α : Type
inst✝ : DecidableEq α
c : α
⊢ { symbol_arrow_list := [{ start_state := 0, symbol := c, stop_state_list := [1] }], epsilon_arrow_list := [],
starting_state_list := [0], accepting_state_list := [1] }.toAbstract =
match_char_AbstractEpsilonNFA c
|
α : Type
inst✝ : DecidableEq α
c : α
⊢ {
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
[{ start_state := 0, symbol := c, stop_state_list := [1] }] ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈ [] ∧ stop_state ∈ stop_state_list,
start := fun state => state ∈ [0], accepting := fun state => state ∈ [1] } =
match_char_AbstractEpsilonNFA c
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : DecidableEq α
c : α
⊢ { symbol_arrow_list := [{ start_state := 0, symbol := c, stop_state_list := [1] }], epsilon_arrow_list := [],
starting_state_list := [0], accepting_state_list := [1] }.toAbstract =
match_char_AbstractEpsilonNFA c
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_char_EpsilonNFA_toAbstract
|
[50, 1]
|
[63, 9]
|
simp only [match_char_AbstractEpsilonNFA]
|
α : Type
inst✝ : DecidableEq α
c : α
⊢ {
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
[{ start_state := 0, symbol := c, stop_state_list := [1] }] ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈ [] ∧ stop_state ∈ stop_state_list,
start := fun state => state ∈ [0], accepting := fun state => state ∈ [1] } =
match_char_AbstractEpsilonNFA c
|
α : Type
inst✝ : DecidableEq α
c : α
⊢ {
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
[{ start_state := 0, symbol := c, stop_state_list := [1] }] ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈ [] ∧ stop_state ∈ stop_state_list,
start := fun state => state ∈ [0], accepting := fun state => state ∈ [1] } =
{ symbol := fun p a q => p = 0 ∧ a = c ∧ q = 1, epsilon := fun x x => False, start := fun p => p = 0,
accepting := fun p => p = 1 }
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : DecidableEq α
c : α
⊢ {
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
[{ start_state := 0, symbol := c, stop_state_list := [1] }] ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈ [] ∧ stop_state ∈ stop_state_list,
start := fun state => state ∈ [0], accepting := fun state => state ∈ [1] } =
match_char_AbstractEpsilonNFA c
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_char_EpsilonNFA_toAbstract
|
[50, 1]
|
[63, 9]
|
simp
|
α : Type
inst✝ : DecidableEq α
c : α
⊢ {
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
[{ start_state := 0, symbol := c, stop_state_list := [1] }] ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈ [] ∧ stop_state ∈ stop_state_list,
start := fun state => state ∈ [0], accepting := fun state => state ∈ [1] } =
{ symbol := fun p a q => p = 0 ∧ a = c ∧ q = 1, epsilon := fun x x => False, start := fun p => p = 0,
accepting := fun p => p = 1 }
|
α : Type
inst✝ : DecidableEq α
c : α
⊢ (fun start_state symbol stop_state =>
∃ stop_state_list, (start_state = 0 ∧ symbol = c ∧ stop_state_list = [1]) ∧ stop_state ∈ stop_state_list) =
fun p a q => p = 0 ∧ a = c ∧ q = 1
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : DecidableEq α
c : α
⊢ {
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
[{ start_state := 0, symbol := c, stop_state_list := [1] }] ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈ [] ∧ stop_state ∈ stop_state_list,
start := fun state => state ∈ [0], accepting := fun state => state ∈ [1] } =
{ symbol := fun p a q => p = 0 ∧ a = c ∧ q = 1, epsilon := fun x x => False, start := fun p => p = 0,
accepting := fun p => p = 1 }
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_char_EpsilonNFA_toAbstract
|
[50, 1]
|
[63, 9]
|
simp only [← and_assoc]
|
α : Type
inst✝ : DecidableEq α
c : α
⊢ (fun start_state symbol stop_state =>
∃ stop_state_list, (start_state = 0 ∧ symbol = c ∧ stop_state_list = [1]) ∧ stop_state ∈ stop_state_list) =
fun p a q => p = 0 ∧ a = c ∧ q = 1
|
α : Type
inst✝ : DecidableEq α
c : α
⊢ (fun start_state symbol stop_state =>
∃ stop_state_list, ((start_state = 0 ∧ symbol = c) ∧ stop_state_list = [1]) ∧ stop_state ∈ stop_state_list) =
fun p a q => (p = 0 ∧ a = c) ∧ q = 1
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : DecidableEq α
c : α
⊢ (fun start_state symbol stop_state =>
∃ stop_state_list, (start_state = 0 ∧ symbol = c ∧ stop_state_list = [1]) ∧ stop_state ∈ stop_state_list) =
fun p a q => p = 0 ∧ a = c ∧ q = 1
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_char_EpsilonNFA_toAbstract
|
[50, 1]
|
[63, 9]
|
simp only [and_right_comm]
|
α : Type
inst✝ : DecidableEq α
c : α
⊢ (fun start_state symbol stop_state =>
∃ stop_state_list, ((start_state = 0 ∧ symbol = c) ∧ stop_state_list = [1]) ∧ stop_state ∈ stop_state_list) =
fun p a q => (p = 0 ∧ a = c) ∧ q = 1
|
α : Type
inst✝ : DecidableEq α
c : α
⊢ (fun start_state symbol stop_state =>
∃ stop_state_list, ((start_state = 0 ∧ symbol = c) ∧ stop_state ∈ stop_state_list) ∧ stop_state_list = [1]) =
fun p a q => (p = 0 ∧ a = c) ∧ q = 1
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : DecidableEq α
c : α
⊢ (fun start_state symbol stop_state =>
∃ stop_state_list, ((start_state = 0 ∧ symbol = c) ∧ stop_state_list = [1]) ∧ stop_state ∈ stop_state_list) =
fun p a q => (p = 0 ∧ a = c) ∧ q = 1
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_char_EpsilonNFA_toAbstract
|
[50, 1]
|
[63, 9]
|
simp
|
α : Type
inst✝ : DecidableEq α
c : α
⊢ (fun start_state symbol stop_state =>
∃ stop_state_list, ((start_state = 0 ∧ symbol = c) ∧ stop_state ∈ stop_state_list) ∧ stop_state_list = [1]) =
fun p a q => (p = 0 ∧ a = c) ∧ q = 1
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : DecidableEq α
c : α
⊢ (fun start_state symbol stop_state =>
∃ stop_state_list, ((start_state = 0 ∧ symbol = c) ∧ stop_state ∈ stop_state_list) ∧ stop_state_list = [1]) =
fun p a q => (p = 0 ∧ a = c) ∧ q = 1
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_epsilon_EpsilonNFA_toAbstract
|
[176, 1]
|
[204, 15]
|
simp only [match_epsilon_EpsilonNFA]
|
α : Type
inst✝ : DecidableEq α
⊢ (match_epsilon_EpsilonNFA α).toAbstract = match_epsilon_AbstractEpsilonNFA α
|
α : Type
inst✝ : DecidableEq α
⊢ { symbol_arrow_list := [], epsilon_arrow_list := [{ start_state := 0, stop_state_list := [1] }],
starting_state_list := [0], accepting_state_list := [1] }.toAbstract =
match_epsilon_AbstractEpsilonNFA α
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : DecidableEq α
⊢ (match_epsilon_EpsilonNFA α).toAbstract = match_epsilon_AbstractEpsilonNFA α
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_epsilon_EpsilonNFA_toAbstract
|
[176, 1]
|
[204, 15]
|
simp only [EpsilonNFA.toAbstract]
|
α : Type
inst✝ : DecidableEq α
⊢ { symbol_arrow_list := [], epsilon_arrow_list := [{ start_state := 0, stop_state_list := [1] }],
starting_state_list := [0], accepting_state_list := [1] }.toAbstract =
match_epsilon_AbstractEpsilonNFA α
|
α : Type
inst✝ : DecidableEq α
⊢ {
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈ [] ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈
[{ start_state := 0, stop_state_list := [1] }] ∧
stop_state ∈ stop_state_list,
start := fun state => state ∈ [0], accepting := fun state => state ∈ [1] } =
match_epsilon_AbstractEpsilonNFA α
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : DecidableEq α
⊢ { symbol_arrow_list := [], epsilon_arrow_list := [{ start_state := 0, stop_state_list := [1] }],
starting_state_list := [0], accepting_state_list := [1] }.toAbstract =
match_epsilon_AbstractEpsilonNFA α
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_epsilon_EpsilonNFA_toAbstract
|
[176, 1]
|
[204, 15]
|
simp only [match_epsilon_AbstractEpsilonNFA]
|
α : Type
inst✝ : DecidableEq α
⊢ {
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈ [] ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈
[{ start_state := 0, stop_state_list := [1] }] ∧
stop_state ∈ stop_state_list,
start := fun state => state ∈ [0], accepting := fun state => state ∈ [1] } =
match_epsilon_AbstractEpsilonNFA α
|
α : Type
inst✝ : DecidableEq α
⊢ {
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈ [] ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈
[{ start_state := 0, stop_state_list := [1] }] ∧
stop_state ∈ stop_state_list,
start := fun state => state ∈ [0], accepting := fun state => state ∈ [1] } =
{ symbol := fun x x x => False, epsilon := fun p q => p = 0 ∧ q = 1, start := fun p => p = 0,
accepting := fun p => p = 1 }
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : DecidableEq α
⊢ {
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈ [] ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈
[{ start_state := 0, stop_state_list := [1] }] ∧
stop_state ∈ stop_state_list,
start := fun state => state ∈ [0], accepting := fun state => state ∈ [1] } =
match_epsilon_AbstractEpsilonNFA α
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_epsilon_EpsilonNFA_toAbstract
|
[176, 1]
|
[204, 15]
|
simp
|
α : Type
inst✝ : DecidableEq α
⊢ {
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈ [] ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈
[{ start_state := 0, stop_state_list := [1] }] ∧
stop_state ∈ stop_state_list,
start := fun state => state ∈ [0], accepting := fun state => state ∈ [1] } =
{ symbol := fun x x x => False, epsilon := fun p q => p = 0 ∧ q = 1, start := fun p => p = 0,
accepting := fun p => p = 1 }
|
α : Type
inst✝ : DecidableEq α
⊢ (fun start_state stop_state =>
∃ stop_state_list, (start_state = 0 ∧ stop_state_list = [1]) ∧ stop_state ∈ stop_state_list) =
fun p q => p = 0 ∧ q = 1
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : DecidableEq α
⊢ {
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈ [] ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈
[{ start_state := 0, stop_state_list := [1] }] ∧
stop_state ∈ stop_state_list,
start := fun state => state ∈ [0], accepting := fun state => state ∈ [1] } =
{ symbol := fun x x x => False, epsilon := fun p q => p = 0 ∧ q = 1, start := fun p => p = 0,
accepting := fun p => p = 1 }
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_epsilon_EpsilonNFA_toAbstract
|
[176, 1]
|
[204, 15]
|
funext p q
|
α : Type
inst✝ : DecidableEq α
⊢ (fun start_state stop_state =>
∃ stop_state_list, (start_state = 0 ∧ stop_state_list = [1]) ∧ stop_state ∈ stop_state_list) =
fun p q => p = 0 ∧ q = 1
|
case h.h
α : Type
inst✝ : DecidableEq α
p q : ℕ
⊢ (∃ stop_state_list, (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list) = (p = 0 ∧ q = 1)
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : DecidableEq α
⊢ (fun start_state stop_state =>
∃ stop_state_list, (start_state = 0 ∧ stop_state_list = [1]) ∧ stop_state ∈ stop_state_list) =
fun p q => p = 0 ∧ q = 1
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_epsilon_EpsilonNFA_toAbstract
|
[176, 1]
|
[204, 15]
|
simp
|
case h.h
α : Type
inst✝ : DecidableEq α
p q : ℕ
⊢ (∃ stop_state_list, (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list) = (p = 0 ∧ q = 1)
|
case h.h
α : Type
inst✝ : DecidableEq α
p q : ℕ
⊢ (∃ stop_state_list, (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list) ↔ p = 0 ∧ q = 1
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.h
α : Type
inst✝ : DecidableEq α
p q : ℕ
⊢ (∃ stop_state_list, (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list) = (p = 0 ∧ q = 1)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_epsilon_EpsilonNFA_toAbstract
|
[176, 1]
|
[204, 15]
|
constructor
|
case h.h
α : Type
inst✝ : DecidableEq α
p q : ℕ
⊢ (∃ stop_state_list, (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list) ↔ p = 0 ∧ q = 1
|
case h.h.mp
α : Type
inst✝ : DecidableEq α
p q : ℕ
⊢ (∃ stop_state_list, (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list) → p = 0 ∧ q = 1
case h.h.mpr
α : Type
inst✝ : DecidableEq α
p q : ℕ
⊢ p = 0 ∧ q = 1 → ∃ stop_state_list, (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.h
α : Type
inst✝ : DecidableEq α
p q : ℕ
⊢ (∃ stop_state_list, (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list) ↔ p = 0 ∧ q = 1
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_epsilon_EpsilonNFA_toAbstract
|
[176, 1]
|
[204, 15]
|
intro a1
|
case h.h.mp
α : Type
inst✝ : DecidableEq α
p q : ℕ
⊢ (∃ stop_state_list, (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list) → p = 0 ∧ q = 1
|
case h.h.mp
α : Type
inst✝ : DecidableEq α
p q : ℕ
a1 : ∃ stop_state_list, (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list
⊢ p = 0 ∧ q = 1
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mp
α : Type
inst✝ : DecidableEq α
p q : ℕ
⊢ (∃ stop_state_list, (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list) → p = 0 ∧ q = 1
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_epsilon_EpsilonNFA_toAbstract
|
[176, 1]
|
[204, 15]
|
apply Exists.elim a1
|
case h.h.mp
α : Type
inst✝ : DecidableEq α
p q : ℕ
a1 : ∃ stop_state_list, (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list
⊢ p = 0 ∧ q = 1
|
case h.h.mp
α : Type
inst✝ : DecidableEq α
p q : ℕ
a1 : ∃ stop_state_list, (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list
⊢ ∀ (a : List ℕ), (p = 0 ∧ a = [1]) ∧ q ∈ a → p = 0 ∧ q = 1
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mp
α : Type
inst✝ : DecidableEq α
p q : ℕ
a1 : ∃ stop_state_list, (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list
⊢ p = 0 ∧ q = 1
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_epsilon_EpsilonNFA_toAbstract
|
[176, 1]
|
[204, 15]
|
intro stop_state_list a2
|
case h.h.mp
α : Type
inst✝ : DecidableEq α
p q : ℕ
a1 : ∃ stop_state_list, (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list
⊢ ∀ (a : List ℕ), (p = 0 ∧ a = [1]) ∧ q ∈ a → p = 0 ∧ q = 1
|
case h.h.mp
α : Type
inst✝ : DecidableEq α
p q : ℕ
a1 : ∃ stop_state_list, (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list
stop_state_list : List ℕ
a2 : (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list
⊢ p = 0 ∧ q = 1
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mp
α : Type
inst✝ : DecidableEq α
p q : ℕ
a1 : ∃ stop_state_list, (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list
⊢ ∀ (a : List ℕ), (p = 0 ∧ a = [1]) ∧ q ∈ a → p = 0 ∧ q = 1
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_epsilon_EpsilonNFA_toAbstract
|
[176, 1]
|
[204, 15]
|
clear a1
|
case h.h.mp
α : Type
inst✝ : DecidableEq α
p q : ℕ
a1 : ∃ stop_state_list, (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list
stop_state_list : List ℕ
a2 : (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list
⊢ p = 0 ∧ q = 1
|
case h.h.mp
α : Type
inst✝ : DecidableEq α
p q : ℕ
stop_state_list : List ℕ
a2 : (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list
⊢ p = 0 ∧ q = 1
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mp
α : Type
inst✝ : DecidableEq α
p q : ℕ
a1 : ∃ stop_state_list, (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list
stop_state_list : List ℕ
a2 : (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list
⊢ p = 0 ∧ q = 1
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_epsilon_EpsilonNFA_toAbstract
|
[176, 1]
|
[204, 15]
|
cases a2
|
case h.h.mp
α : Type
inst✝ : DecidableEq α
p q : ℕ
stop_state_list : List ℕ
a2 : (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list
⊢ p = 0 ∧ q = 1
|
case h.h.mp.intro
α : Type
inst✝ : DecidableEq α
p q : ℕ
stop_state_list : List ℕ
left✝ : p = 0 ∧ stop_state_list = [1]
right✝ : q ∈ stop_state_list
⊢ p = 0 ∧ q = 1
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mp
α : Type
inst✝ : DecidableEq α
p q : ℕ
stop_state_list : List ℕ
a2 : (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list
⊢ p = 0 ∧ q = 1
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_epsilon_EpsilonNFA_toAbstract
|
[176, 1]
|
[204, 15]
|
case _ a2_left a2_right =>
cases a2_left
case _ a2_left_left a2_left_right =>
simp only [a2_left_right] at a2_right
simp at a2_right
tauto
|
α : Type
inst✝ : DecidableEq α
p q : ℕ
stop_state_list : List ℕ
a2_left : p = 0 ∧ stop_state_list = [1]
a2_right : q ∈ stop_state_list
⊢ p = 0 ∧ q = 1
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : DecidableEq α
p q : ℕ
stop_state_list : List ℕ
a2_left : p = 0 ∧ stop_state_list = [1]
a2_right : q ∈ stop_state_list
⊢ p = 0 ∧ q = 1
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_epsilon_EpsilonNFA_toAbstract
|
[176, 1]
|
[204, 15]
|
cases a2_left
|
α : Type
inst✝ : DecidableEq α
p q : ℕ
stop_state_list : List ℕ
a2_left : p = 0 ∧ stop_state_list = [1]
a2_right : q ∈ stop_state_list
⊢ p = 0 ∧ q = 1
|
case intro
α : Type
inst✝ : DecidableEq α
p q : ℕ
stop_state_list : List ℕ
a2_right : q ∈ stop_state_list
left✝ : p = 0
right✝ : stop_state_list = [1]
⊢ p = 0 ∧ q = 1
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : DecidableEq α
p q : ℕ
stop_state_list : List ℕ
a2_left : p = 0 ∧ stop_state_list = [1]
a2_right : q ∈ stop_state_list
⊢ p = 0 ∧ q = 1
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_epsilon_EpsilonNFA_toAbstract
|
[176, 1]
|
[204, 15]
|
case _ a2_left_left a2_left_right =>
simp only [a2_left_right] at a2_right
simp at a2_right
tauto
|
α : Type
inst✝ : DecidableEq α
p q : ℕ
stop_state_list : List ℕ
a2_right : q ∈ stop_state_list
a2_left_left : p = 0
a2_left_right : stop_state_list = [1]
⊢ p = 0 ∧ q = 1
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : DecidableEq α
p q : ℕ
stop_state_list : List ℕ
a2_right : q ∈ stop_state_list
a2_left_left : p = 0
a2_left_right : stop_state_list = [1]
⊢ p = 0 ∧ q = 1
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_epsilon_EpsilonNFA_toAbstract
|
[176, 1]
|
[204, 15]
|
simp only [a2_left_right] at a2_right
|
α : Type
inst✝ : DecidableEq α
p q : ℕ
stop_state_list : List ℕ
a2_right : q ∈ stop_state_list
a2_left_left : p = 0
a2_left_right : stop_state_list = [1]
⊢ p = 0 ∧ q = 1
|
α : Type
inst✝ : DecidableEq α
p q : ℕ
stop_state_list : List ℕ
a2_left_left : p = 0
a2_left_right : stop_state_list = [1]
a2_right : q ∈ [1]
⊢ p = 0 ∧ q = 1
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : DecidableEq α
p q : ℕ
stop_state_list : List ℕ
a2_right : q ∈ stop_state_list
a2_left_left : p = 0
a2_left_right : stop_state_list = [1]
⊢ p = 0 ∧ q = 1
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_epsilon_EpsilonNFA_toAbstract
|
[176, 1]
|
[204, 15]
|
simp at a2_right
|
α : Type
inst✝ : DecidableEq α
p q : ℕ
stop_state_list : List ℕ
a2_left_left : p = 0
a2_left_right : stop_state_list = [1]
a2_right : q ∈ [1]
⊢ p = 0 ∧ q = 1
|
α : Type
inst✝ : DecidableEq α
p q : ℕ
stop_state_list : List ℕ
a2_left_left : p = 0
a2_left_right : stop_state_list = [1]
a2_right : q = 1
⊢ p = 0 ∧ q = 1
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : DecidableEq α
p q : ℕ
stop_state_list : List ℕ
a2_left_left : p = 0
a2_left_right : stop_state_list = [1]
a2_right : q ∈ [1]
⊢ p = 0 ∧ q = 1
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_epsilon_EpsilonNFA_toAbstract
|
[176, 1]
|
[204, 15]
|
tauto
|
α : Type
inst✝ : DecidableEq α
p q : ℕ
stop_state_list : List ℕ
a2_left_left : p = 0
a2_left_right : stop_state_list = [1]
a2_right : q = 1
⊢ p = 0 ∧ q = 1
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : DecidableEq α
p q : ℕ
stop_state_list : List ℕ
a2_left_left : p = 0
a2_left_right : stop_state_list = [1]
a2_right : q = 1
⊢ p = 0 ∧ q = 1
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_epsilon_EpsilonNFA_toAbstract
|
[176, 1]
|
[204, 15]
|
intro a1
|
case h.h.mpr
α : Type
inst✝ : DecidableEq α
p q : ℕ
⊢ p = 0 ∧ q = 1 → ∃ stop_state_list, (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list
|
case h.h.mpr
α : Type
inst✝ : DecidableEq α
p q : ℕ
a1 : p = 0 ∧ q = 1
⊢ ∃ stop_state_list, (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mpr
α : Type
inst✝ : DecidableEq α
p q : ℕ
⊢ p = 0 ∧ q = 1 → ∃ stop_state_list, (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_epsilon_EpsilonNFA_toAbstract
|
[176, 1]
|
[204, 15]
|
apply Exists.intro [1]
|
case h.h.mpr
α : Type
inst✝ : DecidableEq α
p q : ℕ
a1 : p = 0 ∧ q = 1
⊢ ∃ stop_state_list, (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list
|
case h.h.mpr
α : Type
inst✝ : DecidableEq α
p q : ℕ
a1 : p = 0 ∧ q = 1
⊢ (p = 0 ∧ [1] = [1]) ∧ q ∈ [1]
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mpr
α : Type
inst✝ : DecidableEq α
p q : ℕ
a1 : p = 0 ∧ q = 1
⊢ ∃ stop_state_list, (p = 0 ∧ stop_state_list = [1]) ∧ q ∈ stop_state_list
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_epsilon_EpsilonNFA_toAbstract
|
[176, 1]
|
[204, 15]
|
simp
|
case h.h.mpr
α : Type
inst✝ : DecidableEq α
p q : ℕ
a1 : p = 0 ∧ q = 1
⊢ (p = 0 ∧ [1] = [1]) ∧ q ∈ [1]
|
case h.h.mpr
α : Type
inst✝ : DecidableEq α
p q : ℕ
a1 : p = 0 ∧ q = 1
⊢ p = 0 ∧ q = 1
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mpr
α : Type
inst✝ : DecidableEq α
p q : ℕ
a1 : p = 0 ∧ q = 1
⊢ (p = 0 ∧ [1] = [1]) ∧ q ∈ [1]
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_epsilon_EpsilonNFA_toAbstract
|
[176, 1]
|
[204, 15]
|
exact a1
|
case h.h.mpr
α : Type
inst✝ : DecidableEq α
p q : ℕ
a1 : p = 0 ∧ q = 1
⊢ p = 0 ∧ q = 1
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.mpr
α : Type
inst✝ : DecidableEq α
p q : ℕ
a1 : p = 0 ∧ q = 1
⊢ p = 0 ∧ q = 1
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_zero_EpsilonNFA_toAbstract
|
[237, 1]
|
[245, 9]
|
simp only [match_zero_EpsilonNFA]
|
α : Type
inst✝ : DecidableEq α
⊢ (match_zero_EpsilonNFA α).toAbstract = match_zero_AbstractEpsilonNFA α
|
α : Type
inst✝ : DecidableEq α
⊢ { symbol_arrow_list := [], epsilon_arrow_list := [], starting_state_list := [0],
accepting_state_list := [] }.toAbstract =
match_zero_AbstractEpsilonNFA α
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : DecidableEq α
⊢ (match_zero_EpsilonNFA α).toAbstract = match_zero_AbstractEpsilonNFA α
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_zero_EpsilonNFA_toAbstract
|
[237, 1]
|
[245, 9]
|
simp only [EpsilonNFA.toAbstract]
|
α : Type
inst✝ : DecidableEq α
⊢ { symbol_arrow_list := [], epsilon_arrow_list := [], starting_state_list := [0],
accepting_state_list := [] }.toAbstract =
match_zero_AbstractEpsilonNFA α
|
α : Type
inst✝ : DecidableEq α
⊢ {
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈ [] ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈ [] ∧ stop_state ∈ stop_state_list,
start := fun state => state ∈ [0], accepting := fun state => state ∈ [] } =
match_zero_AbstractEpsilonNFA α
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : DecidableEq α
⊢ { symbol_arrow_list := [], epsilon_arrow_list := [], starting_state_list := [0],
accepting_state_list := [] }.toAbstract =
match_zero_AbstractEpsilonNFA α
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_zero_EpsilonNFA_toAbstract
|
[237, 1]
|
[245, 9]
|
simp only [match_zero_AbstractEpsilonNFA]
|
α : Type
inst✝ : DecidableEq α
⊢ {
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈ [] ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈ [] ∧ stop_state ∈ stop_state_list,
start := fun state => state ∈ [0], accepting := fun state => state ∈ [] } =
match_zero_AbstractEpsilonNFA α
|
α : Type
inst✝ : DecidableEq α
⊢ {
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈ [] ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈ [] ∧ stop_state ∈ stop_state_list,
start := fun state => state ∈ [0], accepting := fun state => state ∈ [] } =
{ symbol := fun x x x => False, epsilon := fun x x => False, start := fun p => p = 0, accepting := fun x => False }
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : DecidableEq α
⊢ {
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈ [] ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈ [] ∧ stop_state ∈ stop_state_list,
start := fun state => state ∈ [0], accepting := fun state => state ∈ [] } =
match_zero_AbstractEpsilonNFA α
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_zero_EpsilonNFA_toAbstract
|
[237, 1]
|
[245, 9]
|
simp
|
α : Type
inst✝ : DecidableEq α
⊢ {
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈ [] ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈ [] ∧ stop_state ∈ stop_state_list,
start := fun state => state ∈ [0], accepting := fun state => state ∈ [] } =
{ symbol := fun x x x => False, epsilon := fun x x => False, start := fun p => p = 0, accepting := fun x => False }
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : DecidableEq α
⊢ {
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈ [] ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈ [] ∧ stop_state ∈ stop_state_list,
start := fun state => state ∈ [0], accepting := fun state => state ∈ [] } =
{ symbol := fun x x x => False, epsilon := fun x x => False, start := fun p => p = 0, accepting := fun x => False }
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_union_EpsilonNFA_toAbstract
|
[312, 1]
|
[506, 17]
|
simp only [match_union_EpsilonNFA]
|
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
⊢ (match_union_EpsilonNFA α σ_0 σ_1 M_0 M_1).toAbstract =
match_union_AbstractEpsilonNFA α σ_0 σ_1 M_0.toAbstract M_1.toAbstract
|
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
⊢ {
symbol_arrow_list :=
(EpsilonNFA.wrapLeft σ_1 M_0).symbol_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).symbol_arrow_list,
epsilon_arrow_list :=
(EpsilonNFA.wrapLeft σ_1 M_0).epsilon_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).epsilon_arrow_list,
starting_state_list :=
(EpsilonNFA.wrapLeft σ_1 M_0).starting_state_list ++ (EpsilonNFA.wrapRight σ_0 M_1).starting_state_list,
accepting_state_list :=
(EpsilonNFA.wrapLeft σ_1 M_0).accepting_state_list ++
(EpsilonNFA.wrapRight σ_0 M_1).accepting_state_list }.toAbstract =
match_union_AbstractEpsilonNFA α σ_0 σ_1 M_0.toAbstract M_1.toAbstract
|
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
⊢ (match_union_EpsilonNFA α σ_0 σ_1 M_0 M_1).toAbstract =
match_union_AbstractEpsilonNFA α σ_0 σ_1 M_0.toAbstract M_1.toAbstract
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_union_EpsilonNFA_toAbstract
|
[312, 1]
|
[506, 17]
|
simp only [EpsilonNFA.toAbstract]
|
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
⊢ {
symbol_arrow_list :=
(EpsilonNFA.wrapLeft σ_1 M_0).symbol_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).symbol_arrow_list,
epsilon_arrow_list :=
(EpsilonNFA.wrapLeft σ_1 M_0).epsilon_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).epsilon_arrow_list,
starting_state_list :=
(EpsilonNFA.wrapLeft σ_1 M_0).starting_state_list ++ (EpsilonNFA.wrapRight σ_0 M_1).starting_state_list,
accepting_state_list :=
(EpsilonNFA.wrapLeft σ_1 M_0).accepting_state_list ++
(EpsilonNFA.wrapRight σ_0 M_1).accepting_state_list }.toAbstract =
match_union_AbstractEpsilonNFA α σ_0 σ_1 M_0.toAbstract M_1.toAbstract
|
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
⊢ {
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
(EpsilonNFA.wrapLeft σ_1 M_0).symbol_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).symbol_arrow_list ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈
(EpsilonNFA.wrapLeft σ_1 M_0).epsilon_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).epsilon_arrow_list ∧
stop_state ∈ stop_state_list,
start := fun state =>
state ∈ (EpsilonNFA.wrapLeft σ_1 M_0).starting_state_list ++ (EpsilonNFA.wrapRight σ_0 M_1).starting_state_list,
accepting := fun state =>
state ∈
(EpsilonNFA.wrapLeft σ_1 M_0).accepting_state_list ++ (EpsilonNFA.wrapRight σ_0 M_1).accepting_state_list } =
match_union_AbstractEpsilonNFA α σ_0 σ_1
{
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
M_0.symbol_arrow_list ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧
stop_state ∈ stop_state_list,
start := fun state => state ∈ M_0.starting_state_list,
accepting := fun state => state ∈ M_0.accepting_state_list }
{
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
M_1.symbol_arrow_list ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧
stop_state ∈ stop_state_list,
start := fun state => state ∈ M_1.starting_state_list,
accepting := fun state => state ∈ M_1.accepting_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
⊢ {
symbol_arrow_list :=
(EpsilonNFA.wrapLeft σ_1 M_0).symbol_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).symbol_arrow_list,
epsilon_arrow_list :=
(EpsilonNFA.wrapLeft σ_1 M_0).epsilon_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).epsilon_arrow_list,
starting_state_list :=
(EpsilonNFA.wrapLeft σ_1 M_0).starting_state_list ++ (EpsilonNFA.wrapRight σ_0 M_1).starting_state_list,
accepting_state_list :=
(EpsilonNFA.wrapLeft σ_1 M_0).accepting_state_list ++
(EpsilonNFA.wrapRight σ_0 M_1).accepting_state_list }.toAbstract =
match_union_AbstractEpsilonNFA α σ_0 σ_1 M_0.toAbstract M_1.toAbstract
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_union_EpsilonNFA_toAbstract
|
[312, 1]
|
[506, 17]
|
simp only [match_union_AbstractEpsilonNFA]
|
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
⊢ {
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
(EpsilonNFA.wrapLeft σ_1 M_0).symbol_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).symbol_arrow_list ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈
(EpsilonNFA.wrapLeft σ_1 M_0).epsilon_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).epsilon_arrow_list ∧
stop_state ∈ stop_state_list,
start := fun state =>
state ∈ (EpsilonNFA.wrapLeft σ_1 M_0).starting_state_list ++ (EpsilonNFA.wrapRight σ_0 M_1).starting_state_list,
accepting := fun state =>
state ∈
(EpsilonNFA.wrapLeft σ_1 M_0).accepting_state_list ++ (EpsilonNFA.wrapRight σ_0 M_1).accepting_state_list } =
match_union_AbstractEpsilonNFA α σ_0 σ_1
{
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
M_0.symbol_arrow_list ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧
stop_state ∈ stop_state_list,
start := fun state => state ∈ M_0.starting_state_list,
accepting := fun state => state ∈ M_0.accepting_state_list }
{
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
M_1.symbol_arrow_list ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧
stop_state ∈ stop_state_list,
start := fun state => state ∈ M_1.starting_state_list,
accepting := fun state => state ∈ M_1.accepting_state_list }
|
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
⊢ {
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
(EpsilonNFA.wrapLeft σ_1 M_0).symbol_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).symbol_arrow_list ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈
(EpsilonNFA.wrapLeft σ_1 M_0).epsilon_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).epsilon_arrow_list ∧
stop_state ∈ stop_state_list,
start := fun state =>
state ∈ (EpsilonNFA.wrapLeft σ_1 M_0).starting_state_list ++ (EpsilonNFA.wrapRight σ_0 M_1).starting_state_list,
accepting := fun state =>
state ∈
(EpsilonNFA.wrapLeft σ_1 M_0).accepting_state_list ++ (EpsilonNFA.wrapRight σ_0 M_1).accepting_state_list } =
{
symbol := fun p c q =>
match (p, q) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False,
epsilon := fun p q =>
match (p, q) with
| (Sum.inl p', 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 p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list
| x => False,
start := fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.starting_state_list
| Sum.inr p' => p' ∈ M_1.starting_state_list,
accepting := fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.accepting_state_list
| Sum.inr p' => p' ∈ M_1.accepting_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
⊢ {
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
(EpsilonNFA.wrapLeft σ_1 M_0).symbol_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).symbol_arrow_list ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈
(EpsilonNFA.wrapLeft σ_1 M_0).epsilon_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).epsilon_arrow_list ∧
stop_state ∈ stop_state_list,
start := fun state =>
state ∈ (EpsilonNFA.wrapLeft σ_1 M_0).starting_state_list ++ (EpsilonNFA.wrapRight σ_0 M_1).starting_state_list,
accepting := fun state =>
state ∈
(EpsilonNFA.wrapLeft σ_1 M_0).accepting_state_list ++ (EpsilonNFA.wrapRight σ_0 M_1).accepting_state_list } =
match_union_AbstractEpsilonNFA α σ_0 σ_1
{
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
M_0.symbol_arrow_list ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈ M_0.epsilon_arrow_list ∧
stop_state ∈ stop_state_list,
start := fun state => state ∈ M_0.starting_state_list,
accepting := fun state => state ∈ M_0.accepting_state_list }
{
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
M_1.symbol_arrow_list ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧
stop_state ∈ stop_state_list,
start := fun state => state ∈ M_1.starting_state_list,
accepting := fun state => state ∈ M_1.accepting_state_list }
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_union_EpsilonNFA_toAbstract
|
[312, 1]
|
[506, 17]
|
simp only [AbstractEpsilonNFA.mk.injEq]
|
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
⊢ {
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
(EpsilonNFA.wrapLeft σ_1 M_0).symbol_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).symbol_arrow_list ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈
(EpsilonNFA.wrapLeft σ_1 M_0).epsilon_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).epsilon_arrow_list ∧
stop_state ∈ stop_state_list,
start := fun state =>
state ∈ (EpsilonNFA.wrapLeft σ_1 M_0).starting_state_list ++ (EpsilonNFA.wrapRight σ_0 M_1).starting_state_list,
accepting := fun state =>
state ∈
(EpsilonNFA.wrapLeft σ_1 M_0).accepting_state_list ++ (EpsilonNFA.wrapRight σ_0 M_1).accepting_state_list } =
{
symbol := fun p c q =>
match (p, q) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False,
epsilon := fun p q =>
match (p, q) with
| (Sum.inl p', 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 p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list
| x => False,
start := fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.starting_state_list
| Sum.inr p' => p' ∈ M_1.starting_state_list,
accepting := fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.accepting_state_list
| Sum.inr p' => p' ∈ M_1.accepting_state_list }
|
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
⊢ ((fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
(EpsilonNFA.wrapLeft σ_1 M_0).symbol_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).symbol_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p c q =>
match (p, q) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False) ∧
((fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈
(EpsilonNFA.wrapLeft σ_1 M_0).epsilon_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).epsilon_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p q =>
match (p, q) with
| (Sum.inl p', 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 p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list
| x => False) ∧
((fun state =>
state ∈
(EpsilonNFA.wrapLeft σ_1 M_0).starting_state_list ++ (EpsilonNFA.wrapRight σ_0 M_1).starting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.starting_state_list
| Sum.inr p' => p' ∈ M_1.starting_state_list) ∧
(fun state =>
state ∈
(EpsilonNFA.wrapLeft σ_1 M_0).accepting_state_list ++
(EpsilonNFA.wrapRight σ_0 M_1).accepting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.accepting_state_list
| Sum.inr p' => p' ∈ M_1.accepting_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
⊢ {
symbol := fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
(EpsilonNFA.wrapLeft σ_1 M_0).symbol_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).symbol_arrow_list ∧
stop_state ∈ stop_state_list,
epsilon := fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈
(EpsilonNFA.wrapLeft σ_1 M_0).epsilon_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).epsilon_arrow_list ∧
stop_state ∈ stop_state_list,
start := fun state =>
state ∈ (EpsilonNFA.wrapLeft σ_1 M_0).starting_state_list ++ (EpsilonNFA.wrapRight σ_0 M_1).starting_state_list,
accepting := fun state =>
state ∈
(EpsilonNFA.wrapLeft σ_1 M_0).accepting_state_list ++ (EpsilonNFA.wrapRight σ_0 M_1).accepting_state_list } =
{
symbol := fun p c q =>
match (p, q) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False,
epsilon := fun p q =>
match (p, q) with
| (Sum.inl p', 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 p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list
| x => False,
start := fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.starting_state_list
| Sum.inr p' => p' ∈ M_1.starting_state_list,
accepting := fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.accepting_state_list
| Sum.inr p' => p' ∈ M_1.accepting_state_list }
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_union_EpsilonNFA_toAbstract
|
[312, 1]
|
[506, 17]
|
simp only [EpsilonNFA.wrapLeft]
|
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
⊢ ((fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
(EpsilonNFA.wrapLeft σ_1 M_0).symbol_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).symbol_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p c q =>
match (p, q) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False) ∧
((fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈
(EpsilonNFA.wrapLeft σ_1 M_0).epsilon_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).epsilon_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p q =>
match (p, q) with
| (Sum.inl p', 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 p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list
| x => False) ∧
((fun state =>
state ∈
(EpsilonNFA.wrapLeft σ_1 M_0).starting_state_list ++ (EpsilonNFA.wrapRight σ_0 M_1).starting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.starting_state_list
| Sum.inr p' => p' ∈ M_1.starting_state_list) ∧
(fun state =>
state ∈
(EpsilonNFA.wrapLeft σ_1 M_0).accepting_state_list ++
(EpsilonNFA.wrapRight σ_0 M_1).accepting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.accepting_state_list
| Sum.inr p' => p' ∈ M_1.accepting_state_list
|
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
⊢ ((fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
(EpsilonNFA.map Sum.inl M_0).symbol_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).symbol_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p c q =>
match (p, q) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False) ∧
((fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈
(EpsilonNFA.map Sum.inl M_0).epsilon_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).epsilon_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p q =>
match (p, q) with
| (Sum.inl p', 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 p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list
| x => False) ∧
((fun state =>
state ∈
(EpsilonNFA.map Sum.inl M_0).starting_state_list ++ (EpsilonNFA.wrapRight σ_0 M_1).starting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.starting_state_list
| Sum.inr p' => p' ∈ M_1.starting_state_list) ∧
(fun state =>
state ∈
(EpsilonNFA.map Sum.inl M_0).accepting_state_list ++
(EpsilonNFA.wrapRight σ_0 M_1).accepting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.accepting_state_list
| Sum.inr p' => p' ∈ M_1.accepting_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
⊢ ((fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
(EpsilonNFA.wrapLeft σ_1 M_0).symbol_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).symbol_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p c q =>
match (p, q) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False) ∧
((fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈
(EpsilonNFA.wrapLeft σ_1 M_0).epsilon_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).epsilon_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p q =>
match (p, q) with
| (Sum.inl p', 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 p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list
| x => False) ∧
((fun state =>
state ∈
(EpsilonNFA.wrapLeft σ_1 M_0).starting_state_list ++ (EpsilonNFA.wrapRight σ_0 M_1).starting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.starting_state_list
| Sum.inr p' => p' ∈ M_1.starting_state_list) ∧
(fun state =>
state ∈
(EpsilonNFA.wrapLeft σ_1 M_0).accepting_state_list ++
(EpsilonNFA.wrapRight σ_0 M_1).accepting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.accepting_state_list
| Sum.inr p' => p' ∈ M_1.accepting_state_list
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_union_EpsilonNFA_toAbstract
|
[312, 1]
|
[506, 17]
|
simp only [EpsilonNFA.wrapRight]
|
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
⊢ ((fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
(EpsilonNFA.map Sum.inl M_0).symbol_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).symbol_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p c q =>
match (p, q) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False) ∧
((fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈
(EpsilonNFA.map Sum.inl M_0).epsilon_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).epsilon_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p q =>
match (p, q) with
| (Sum.inl p', 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 p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list
| x => False) ∧
((fun state =>
state ∈
(EpsilonNFA.map Sum.inl M_0).starting_state_list ++ (EpsilonNFA.wrapRight σ_0 M_1).starting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.starting_state_list
| Sum.inr p' => p' ∈ M_1.starting_state_list) ∧
(fun state =>
state ∈
(EpsilonNFA.map Sum.inl M_0).accepting_state_list ++
(EpsilonNFA.wrapRight σ_0 M_1).accepting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.accepting_state_list
| Sum.inr p' => p' ∈ M_1.accepting_state_list
|
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
⊢ ((fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
(EpsilonNFA.map Sum.inl M_0).symbol_arrow_list ++ (EpsilonNFA.map Sum.inr M_1).symbol_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p c q =>
match (p, q) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False) ∧
((fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈
(EpsilonNFA.map Sum.inl M_0).epsilon_arrow_list ++ (EpsilonNFA.map Sum.inr M_1).epsilon_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p q =>
match (p, q) with
| (Sum.inl p', 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 p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list
| x => False) ∧
((fun state =>
state ∈
(EpsilonNFA.map Sum.inl M_0).starting_state_list ++ (EpsilonNFA.map Sum.inr M_1).starting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.starting_state_list
| Sum.inr p' => p' ∈ M_1.starting_state_list) ∧
(fun state =>
state ∈
(EpsilonNFA.map Sum.inl M_0).accepting_state_list ++ (EpsilonNFA.map Sum.inr M_1).accepting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.accepting_state_list
| Sum.inr p' => p' ∈ M_1.accepting_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
⊢ ((fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
(EpsilonNFA.map Sum.inl M_0).symbol_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).symbol_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p c q =>
match (p, q) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False) ∧
((fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈
(EpsilonNFA.map Sum.inl M_0).epsilon_arrow_list ++ (EpsilonNFA.wrapRight σ_0 M_1).epsilon_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p q =>
match (p, q) with
| (Sum.inl p', 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 p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list
| x => False) ∧
((fun state =>
state ∈
(EpsilonNFA.map Sum.inl M_0).starting_state_list ++ (EpsilonNFA.wrapRight σ_0 M_1).starting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.starting_state_list
| Sum.inr p' => p' ∈ M_1.starting_state_list) ∧
(fun state =>
state ∈
(EpsilonNFA.map Sum.inl M_0).accepting_state_list ++
(EpsilonNFA.wrapRight σ_0 M_1).accepting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.accepting_state_list
| Sum.inr p' => p' ∈ M_1.accepting_state_list
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_union_EpsilonNFA_toAbstract
|
[312, 1]
|
[506, 17]
|
simp only [EpsilonNFA.map]
|
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
⊢ ((fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
(EpsilonNFA.map Sum.inl M_0).symbol_arrow_list ++ (EpsilonNFA.map Sum.inr M_1).symbol_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p c q =>
match (p, q) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False) ∧
((fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈
(EpsilonNFA.map Sum.inl M_0).epsilon_arrow_list ++ (EpsilonNFA.map Sum.inr M_1).epsilon_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p q =>
match (p, q) with
| (Sum.inl p', 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 p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list
| x => False) ∧
((fun state =>
state ∈
(EpsilonNFA.map Sum.inl M_0).starting_state_list ++ (EpsilonNFA.map Sum.inr M_1).starting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.starting_state_list
| Sum.inr p' => p' ∈ M_1.starting_state_list) ∧
(fun state =>
state ∈
(EpsilonNFA.map Sum.inl M_0).accepting_state_list ++ (EpsilonNFA.map Sum.inr M_1).accepting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.accepting_state_list
| Sum.inr p' => p' ∈ M_1.accepting_state_list
|
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
⊢ ((fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p c q =>
match (p, q) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False) ∧
((fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := 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 })
M_1.epsilon_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p q =>
match (p, q) with
| (Sum.inl p', 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 p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list
| x => False) ∧
((fun state => state ∈ List.map Sum.inl M_0.starting_state_list ++ List.map Sum.inr M_1.starting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.starting_state_list
| Sum.inr p' => p' ∈ M_1.starting_state_list) ∧
(fun state => state ∈ List.map Sum.inl M_0.accepting_state_list ++ List.map Sum.inr M_1.accepting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.accepting_state_list
| Sum.inr p' => p' ∈ M_1.accepting_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
⊢ ((fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
(EpsilonNFA.map Sum.inl M_0).symbol_arrow_list ++ (EpsilonNFA.map Sum.inr M_1).symbol_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p c q =>
match (p, q) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False) ∧
((fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := stop_state_list } ∈
(EpsilonNFA.map Sum.inl M_0).epsilon_arrow_list ++ (EpsilonNFA.map Sum.inr M_1).epsilon_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p q =>
match (p, q) with
| (Sum.inl p', 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 p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list
| x => False) ∧
((fun state =>
state ∈
(EpsilonNFA.map Sum.inl M_0).starting_state_list ++ (EpsilonNFA.map Sum.inr M_1).starting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.starting_state_list
| Sum.inr p' => p' ∈ M_1.starting_state_list) ∧
(fun state =>
state ∈
(EpsilonNFA.map Sum.inl M_0).accepting_state_list ++ (EpsilonNFA.map Sum.inr M_1).accepting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.accepting_state_list
| Sum.inr p' => p' ∈ M_1.accepting_state_list
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_union_EpsilonNFA_toAbstract
|
[312, 1]
|
[506, 17]
|
constructor
|
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
⊢ ((fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p c q =>
match (p, q) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False) ∧
((fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := 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 })
M_1.epsilon_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p q =>
match (p, q) with
| (Sum.inl p', 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 p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list
| x => False) ∧
((fun state => state ∈ List.map Sum.inl M_0.starting_state_list ++ List.map Sum.inr M_1.starting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.starting_state_list
| Sum.inr p' => p' ∈ M_1.starting_state_list) ∧
(fun state => state ∈ List.map Sum.inl M_0.accepting_state_list ++ List.map Sum.inr M_1.accepting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.accepting_state_list
| Sum.inr p' => p' ∈ M_1.accepting_state_list
|
case left
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
⊢ (fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p c q =>
match (p, q) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False
case right
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
⊢ ((fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := 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 })
M_1.epsilon_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p q =>
match (p, q) with
| (Sum.inl p', 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 p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list
| x => False) ∧
((fun state => state ∈ List.map Sum.inl M_0.starting_state_list ++ List.map Sum.inr M_1.starting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.starting_state_list
| Sum.inr p' => p' ∈ M_1.starting_state_list) ∧
(fun state => state ∈ List.map Sum.inl M_0.accepting_state_list ++ List.map Sum.inr M_1.accepting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.accepting_state_list
| Sum.inr p' => p' ∈ M_1.accepting_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
⊢ ((fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p c q =>
match (p, q) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False) ∧
((fun start_state stop_state =>
∃ stop_state_list,
{ start_state := start_state, stop_state_list := 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 })
M_1.epsilon_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p q =>
match (p, q) with
| (Sum.inl p', 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 p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', stop_state_list := stop_state_list } ∈ M_1.epsilon_arrow_list ∧ q' ∈ stop_state_list
| x => False) ∧
((fun state => state ∈ List.map Sum.inl M_0.starting_state_list ++ List.map Sum.inr M_1.starting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.starting_state_list
| Sum.inr p' => p' ∈ M_1.starting_state_list) ∧
(fun state => state ∈ List.map Sum.inl M_0.accepting_state_list ++ List.map Sum.inr M_1.accepting_state_list) =
fun p =>
match p with
| Sum.inl p' => p' ∈ M_0.accepting_state_list
| Sum.inr p' => p' ∈ M_1.accepting_state_list
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_union_EpsilonNFA_toAbstract
|
[312, 1]
|
[506, 17]
|
funext p c q
|
case left
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
⊢ (fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p c q =>
match (p, q) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False
|
case left.h.h.h
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
p : σ_0 ⊕ σ_1
c : α
q : σ_0 ⊕ σ_1
⊢ (∃ stop_state_list,
{ start_state := p, symbol := c, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
q ∈ stop_state_list) =
match (p, q) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False
|
Please generate a tactic in lean4 to solve the state.
STATE:
case left
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
⊢ (fun start_state symbol stop_state =>
∃ stop_state_list,
{ start_state := start_state, symbol := symbol, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
stop_state ∈ stop_state_list) =
fun p c q =>
match (p, q) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_union_EpsilonNFA_toAbstract
|
[312, 1]
|
[506, 17]
|
cases p
|
case left.h.h.h
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
p : σ_0 ⊕ σ_1
c : α
q : σ_0 ⊕ σ_1
⊢ (∃ stop_state_list,
{ start_state := p, symbol := c, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
q ∈ stop_state_list) =
match (p, q) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False
|
case left.h.h.h.inl
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
q : σ_0 ⊕ σ_1
val✝ : σ_0
⊢ (∃ stop_state_list,
{ start_state := Sum.inl val✝, symbol := c, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
q ∈ stop_state_list) =
match (Sum.inl val✝, q) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False
case left.h.h.h.inr
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
q : σ_0 ⊕ σ_1
val✝ : σ_1
⊢ (∃ stop_state_list,
{ start_state := Sum.inr val✝, symbol := c, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
q ∈ stop_state_list) =
match (Sum.inr val✝, q) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False
|
Please generate a tactic in lean4 to solve the state.
STATE:
case left.h.h.h
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
p : σ_0 ⊕ σ_1
c : α
q : σ_0 ⊕ σ_1
⊢ (∃ stop_state_list,
{ start_state := p, symbol := c, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
q ∈ stop_state_list) =
match (p, q) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_union_EpsilonNFA_toAbstract
|
[312, 1]
|
[506, 17]
|
cases q
|
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
q : σ_0 ⊕ σ_1
p_0 : σ_0
⊢ (∃ stop_state_list,
{ start_state := Sum.inl p_0, symbol := c, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
q ∈ stop_state_list) =
match (Sum.inl p_0, q) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False
|
case inl
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 val✝ : σ_0
⊢ (∃ stop_state_list,
{ start_state := Sum.inl p_0, symbol := c, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
Sum.inl val✝ ∈ stop_state_list) =
match (Sum.inl p_0, Sum.inl val✝) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False
case inr
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 : σ_0
val✝ : σ_1
⊢ (∃ stop_state_list,
{ start_state := Sum.inl p_0, symbol := c, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
Sum.inr val✝ ∈ stop_state_list) =
match (Sum.inl p_0, Sum.inr val✝) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_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
c : α
q : σ_0 ⊕ σ_1
p_0 : σ_0
⊢ (∃ stop_state_list,
{ start_state := Sum.inl p_0, symbol := c, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
q ∈ stop_state_list) =
match (Sum.inl p_0, q) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_union_EpsilonNFA_toAbstract
|
[312, 1]
|
[506, 17]
|
case _ q0 =>
simp
intro xs x _ _ _ a4
simp only [← a4]
simp
|
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 : σ_0
q0 : σ_1
⊢ (∃ stop_state_list,
{ start_state := Sum.inl p_0, symbol := c, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
Sum.inr q0 ∈ stop_state_list) =
match (Sum.inl p_0, Sum.inr q0) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_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
c : α
p_0 : σ_0
q0 : σ_1
⊢ (∃ stop_state_list,
{ start_state := Sum.inl p_0, symbol := c, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
Sum.inr q0 ∈ stop_state_list) =
match (Sum.inl p_0, Sum.inr q0) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_union_EpsilonNFA_toAbstract
|
[312, 1]
|
[506, 17]
|
simp only [eq_iff_iff]
|
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
⊢ (∃ stop_state_list,
{ start_state := Sum.inl p_0, symbol := c, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
Sum.inl q_0 ∈ stop_state_list) =
match (Sum.inl p_0, Sum.inl q_0) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False
|
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
⊢ (∃ stop_state_list,
{ start_state := Sum.inl p_0, symbol := c, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
Sum.inl q_0 ∈ stop_state_list) ↔
∃ stop_state_list,
{ start_state := p_0, symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_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
c : α
p_0 q_0 : σ_0
⊢ (∃ stop_state_list,
{ start_state := Sum.inl p_0, symbol := c, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
Sum.inl q_0 ∈ stop_state_list) =
match (Sum.inl p_0, Sum.inl q_0) with
| (Sum.inl p', Sum.inl q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q' ∈ stop_state_list
| (Sum.inr p', Sum.inr q') =>
∃ stop_state_list,
{ start_state := p', symbol := c, stop_state_list := stop_state_list } ∈ M_1.symbol_arrow_list ∧
q' ∈ stop_state_list
| x => False
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_union_EpsilonNFA_toAbstract
|
[312, 1]
|
[506, 17]
|
constructor
|
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
⊢ (∃ stop_state_list,
{ start_state := Sum.inl p_0, symbol := c, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
Sum.inl q_0 ∈ stop_state_list) ↔
∃ stop_state_list,
{ start_state := p_0, symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ stop_state_list
|
case mp
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
⊢ (∃ stop_state_list,
{ start_state := Sum.inl p_0, symbol := c, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
Sum.inl q_0 ∈ stop_state_list) →
∃ stop_state_list,
{ start_state := p_0, symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ stop_state_list
case mpr
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
⊢ (∃ stop_state_list,
{ start_state := p_0, symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ stop_state_list) →
∃ stop_state_list,
{ start_state := Sum.inl p_0, symbol := c, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
Sum.inl 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
c : α
p_0 q_0 : σ_0
⊢ (∃ stop_state_list,
{ start_state := Sum.inl p_0, symbol := c, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
Sum.inl q_0 ∈ stop_state_list) ↔
∃ stop_state_list,
{ start_state := p_0, symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ stop_state_list
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_union_EpsilonNFA_toAbstract
|
[312, 1]
|
[506, 17]
|
simp
|
case mp
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
⊢ (∃ stop_state_list,
{ start_state := Sum.inl p_0, symbol := c, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
Sum.inl q_0 ∈ stop_state_list) →
∃ stop_state_list,
{ start_state := p_0, symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ stop_state_list
|
case mp
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
⊢ ∀ (x : List (σ_0 ⊕ σ_1)),
∀ x_1 ∈ M_0.symbol_arrow_list,
x_1.start_state = p_0 →
x_1.symbol = c →
List.map Sum.inl x_1.stop_state_list = x →
Sum.inl q_0 ∈ x →
∃ stop_state_list,
{ start_state := p_0, symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ stop_state_list
|
Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
⊢ (∃ stop_state_list,
{ start_state := Sum.inl p_0, symbol := c, stop_state_list := stop_state_list } ∈
List.map
(fun arrow =>
{ start_state := Sum.inl arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inl arrow.stop_state_list })
M_0.symbol_arrow_list ++
List.map
(fun arrow =>
{ start_state := Sum.inr arrow.start_state, symbol := arrow.symbol,
stop_state_list := List.map Sum.inr arrow.stop_state_list })
M_1.symbol_arrow_list ∧
Sum.inl q_0 ∈ stop_state_list) →
∃ stop_state_list,
{ start_state := p_0, symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ stop_state_list
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_union_EpsilonNFA_toAbstract
|
[312, 1]
|
[506, 17]
|
intro xs x a1 a2 a3 a4 a5
|
case mp
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
⊢ ∀ (x : List (σ_0 ⊕ σ_1)),
∀ x_1 ∈ M_0.symbol_arrow_list,
x_1.start_state = p_0 →
x_1.symbol = c →
List.map Sum.inl x_1.stop_state_list = x →
Sum.inl q_0 ∈ x →
∃ stop_state_list,
{ start_state := p_0, symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ stop_state_list
|
case mp
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
xs : List (σ_0 ⊕ σ_1)
x : SymbolArrow α σ_0
a1 : x ∈ M_0.symbol_arrow_list
a2 : x.start_state = p_0
a3 : x.symbol = c
a4 : List.map Sum.inl x.stop_state_list = xs
a5 : Sum.inl q_0 ∈ xs
⊢ ∃ stop_state_list,
{ start_state := p_0, symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ stop_state_list
|
Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
⊢ ∀ (x : List (σ_0 ⊕ σ_1)),
∀ x_1 ∈ M_0.symbol_arrow_list,
x_1.start_state = p_0 →
x_1.symbol = c →
List.map Sum.inl x_1.stop_state_list = x →
Sum.inl q_0 ∈ x →
∃ stop_state_list,
{ start_state := p_0, symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ stop_state_list
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_union_EpsilonNFA_toAbstract
|
[312, 1]
|
[506, 17]
|
simp only [← a4] at a5
|
case mp
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
xs : List (σ_0 ⊕ σ_1)
x : SymbolArrow α σ_0
a1 : x ∈ M_0.symbol_arrow_list
a2 : x.start_state = p_0
a3 : x.symbol = c
a4 : List.map Sum.inl x.stop_state_list = xs
a5 : Sum.inl q_0 ∈ xs
⊢ ∃ stop_state_list,
{ start_state := p_0, symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ stop_state_list
|
case mp
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
xs : List (σ_0 ⊕ σ_1)
x : SymbolArrow α σ_0
a1 : x ∈ M_0.symbol_arrow_list
a2 : x.start_state = p_0
a3 : x.symbol = c
a4 : List.map Sum.inl x.stop_state_list = xs
a5 : Sum.inl q_0 ∈ List.map Sum.inl x.stop_state_list
⊢ ∃ stop_state_list,
{ start_state := p_0, symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ stop_state_list
|
Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
xs : List (σ_0 ⊕ σ_1)
x : SymbolArrow α σ_0
a1 : x ∈ M_0.symbol_arrow_list
a2 : x.start_state = p_0
a3 : x.symbol = c
a4 : List.map Sum.inl x.stop_state_list = xs
a5 : Sum.inl q_0 ∈ xs
⊢ ∃ stop_state_list,
{ start_state := p_0, symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ stop_state_list
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_union_EpsilonNFA_toAbstract
|
[312, 1]
|
[506, 17]
|
clear a4
|
case mp
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
xs : List (σ_0 ⊕ σ_1)
x : SymbolArrow α σ_0
a1 : x ∈ M_0.symbol_arrow_list
a2 : x.start_state = p_0
a3 : x.symbol = c
a4 : List.map Sum.inl x.stop_state_list = xs
a5 : Sum.inl q_0 ∈ List.map Sum.inl x.stop_state_list
⊢ ∃ stop_state_list,
{ start_state := p_0, symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ stop_state_list
|
case mp
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
xs : List (σ_0 ⊕ σ_1)
x : SymbolArrow α σ_0
a1 : x ∈ M_0.symbol_arrow_list
a2 : x.start_state = p_0
a3 : x.symbol = c
a5 : Sum.inl q_0 ∈ List.map Sum.inl x.stop_state_list
⊢ ∃ stop_state_list,
{ start_state := p_0, symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ stop_state_list
|
Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
xs : List (σ_0 ⊕ σ_1)
x : SymbolArrow α σ_0
a1 : x ∈ M_0.symbol_arrow_list
a2 : x.start_state = p_0
a3 : x.symbol = c
a4 : List.map Sum.inl x.stop_state_list = xs
a5 : Sum.inl q_0 ∈ List.map Sum.inl x.stop_state_list
⊢ ∃ stop_state_list,
{ start_state := p_0, symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ stop_state_list
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_union_EpsilonNFA_toAbstract
|
[312, 1]
|
[506, 17]
|
simp only [← a2]
|
case mp
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
xs : List (σ_0 ⊕ σ_1)
x : SymbolArrow α σ_0
a1 : x ∈ M_0.symbol_arrow_list
a2 : x.start_state = p_0
a3 : x.symbol = c
a5 : Sum.inl q_0 ∈ List.map Sum.inl x.stop_state_list
⊢ ∃ stop_state_list,
{ start_state := p_0, symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ stop_state_list
|
case mp
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
xs : List (σ_0 ⊕ σ_1)
x : SymbolArrow α σ_0
a1 : x ∈ M_0.symbol_arrow_list
a2 : x.start_state = p_0
a3 : x.symbol = c
a5 : Sum.inl q_0 ∈ List.map Sum.inl x.stop_state_list
⊢ ∃ stop_state_list,
{ start_state := x.start_state, symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ stop_state_list
|
Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
xs : List (σ_0 ⊕ σ_1)
x : SymbolArrow α σ_0
a1 : x ∈ M_0.symbol_arrow_list
a2 : x.start_state = p_0
a3 : x.symbol = c
a5 : Sum.inl q_0 ∈ List.map Sum.inl x.stop_state_list
⊢ ∃ stop_state_list,
{ start_state := p_0, symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ stop_state_list
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_union_EpsilonNFA_toAbstract
|
[312, 1]
|
[506, 17]
|
simp only [← a3]
|
case mp
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
xs : List (σ_0 ⊕ σ_1)
x : SymbolArrow α σ_0
a1 : x ∈ M_0.symbol_arrow_list
a2 : x.start_state = p_0
a3 : x.symbol = c
a5 : Sum.inl q_0 ∈ List.map Sum.inl x.stop_state_list
⊢ ∃ stop_state_list,
{ start_state := x.start_state, symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ stop_state_list
|
case mp
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
xs : List (σ_0 ⊕ σ_1)
x : SymbolArrow α σ_0
a1 : x ∈ M_0.symbol_arrow_list
a2 : x.start_state = p_0
a3 : x.symbol = c
a5 : Sum.inl q_0 ∈ List.map Sum.inl x.stop_state_list
⊢ ∃ stop_state_list,
{ start_state := x.start_state, symbol := x.symbol, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ stop_state_list
|
Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
xs : List (σ_0 ⊕ σ_1)
x : SymbolArrow α σ_0
a1 : x ∈ M_0.symbol_arrow_list
a2 : x.start_state = p_0
a3 : x.symbol = c
a5 : Sum.inl q_0 ∈ List.map Sum.inl x.stop_state_list
⊢ ∃ stop_state_list,
{ start_state := x.start_state, symbol := c, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ stop_state_list
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_union_EpsilonNFA_toAbstract
|
[312, 1]
|
[506, 17]
|
apply Exists.intro x.stop_state_list
|
case mp
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
xs : List (σ_0 ⊕ σ_1)
x : SymbolArrow α σ_0
a1 : x ∈ M_0.symbol_arrow_list
a2 : x.start_state = p_0
a3 : x.symbol = c
a5 : Sum.inl q_0 ∈ List.map Sum.inl x.stop_state_list
⊢ ∃ stop_state_list,
{ start_state := x.start_state, symbol := x.symbol, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ stop_state_list
|
case mp
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
xs : List (σ_0 ⊕ σ_1)
x : SymbolArrow α σ_0
a1 : x ∈ M_0.symbol_arrow_list
a2 : x.start_state = p_0
a3 : x.symbol = c
a5 : Sum.inl q_0 ∈ List.map Sum.inl x.stop_state_list
⊢ { start_state := x.start_state, symbol := x.symbol, stop_state_list := x.stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ x.stop_state_list
|
Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
xs : List (σ_0 ⊕ σ_1)
x : SymbolArrow α σ_0
a1 : x ∈ M_0.symbol_arrow_list
a2 : x.start_state = p_0
a3 : x.symbol = c
a5 : Sum.inl q_0 ∈ List.map Sum.inl x.stop_state_list
⊢ ∃ stop_state_list,
{ start_state := x.start_state, symbol := x.symbol, stop_state_list := stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ stop_state_list
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExpToEpsilonNFA.lean
|
match_union_EpsilonNFA_toAbstract
|
[312, 1]
|
[506, 17]
|
constructor
|
case mp
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
xs : List (σ_0 ⊕ σ_1)
x : SymbolArrow α σ_0
a1 : x ∈ M_0.symbol_arrow_list
a2 : x.start_state = p_0
a3 : x.symbol = c
a5 : Sum.inl q_0 ∈ List.map Sum.inl x.stop_state_list
⊢ { start_state := x.start_state, symbol := x.symbol, stop_state_list := x.stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ x.stop_state_list
|
case mp.left
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
xs : List (σ_0 ⊕ σ_1)
x : SymbolArrow α σ_0
a1 : x ∈ M_0.symbol_arrow_list
a2 : x.start_state = p_0
a3 : x.symbol = c
a5 : Sum.inl q_0 ∈ List.map Sum.inl x.stop_state_list
⊢ { start_state := x.start_state, symbol := x.symbol, stop_state_list := x.stop_state_list } ∈ M_0.symbol_arrow_list
case mp.right
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
xs : List (σ_0 ⊕ σ_1)
x : SymbolArrow α σ_0
a1 : x ∈ M_0.symbol_arrow_list
a2 : x.start_state = p_0
a3 : x.symbol = c
a5 : Sum.inl q_0 ∈ List.map Sum.inl x.stop_state_list
⊢ q_0 ∈ x.stop_state_list
|
Please generate a tactic in lean4 to solve the state.
STATE:
case mp
α : Type
inst✝ : DecidableEq α
σ_0 σ_1 : Type
M_0 : EpsilonNFA α σ_0
M_1 : EpsilonNFA α σ_1
c : α
p_0 q_0 : σ_0
xs : List (σ_0 ⊕ σ_1)
x : SymbolArrow α σ_0
a1 : x ∈ M_0.symbol_arrow_list
a2 : x.start_state = p_0
a3 : x.symbol = c
a5 : Sum.inl q_0 ∈ List.map Sum.inl x.stop_state_list
⊢ { start_state := x.start_state, symbol := x.symbol, stop_state_list := x.stop_state_list } ∈ M_0.symbol_arrow_list ∧
q_0 ∈ x.stop_state_list
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.